普通主机服务下用PHP实现端口转发可行吗？求相关方案

Great question—this is a super common workaround for folks stuck on basic shared hosting where you can't run dedicated proxy or tunnel software. Let's break down how this can work, along with practical code examples and key caveats to watch out for.

First off: you can't do true TCP port forwarding with PHP alone, since PHP is HTTP-request-driven and can't maintain persistent listening sockets like a dedicated proxy. But you can build an HTTP-based message relay that mimics the functionality. The core idea is:

1. Remote clients send requests to your PHP endpoint.
2. Your PHP script stores these requests temporarily (files, database, etc.).
3. Your local program polls the PHP endpoint regularly to fetch pending requests.
4. The local program forwards the request to your local server, grabs the response, and sends it back to PHP.
5. PHP delivers the response to the waiting remote client (via long-polling or client-side polling).

Let's build this with file-based storage (the simplest option for most shared hosting setups). First, create two directories on your host: requests/ and responses/, and make sure they have read/write permissions.

1. Client Request Handler (client_request.php) #

This script accepts client requests, stores them, and waits for a response (or returns a request ID for polling if it times out):

<?php
ini_set('max_execution_time', 30); // Extend timeout for long-polling

// Generate unique request ID
$requestId = uniqid('req_', true);

// Capture full request details
$requestData = [
    'method' => $_SERVER['REQUEST_METHOD'],
    'headers' => getallheaders(),
    'body' => file_get_contents('php://input'),
    'timestamp' => time()
];

// Store request
file_put_contents("./requests/{$requestId}.json", json_encode($requestData));

// Long-poll for response (max 30 seconds)
$timeout = time() + 30;
while (time() < $timeout) {
    if (file_exists("./responses/{$requestId}.json")) {
        // Fetch and return response
        $response = json_decode(file_get_contents("./responses/{$requestId}.json"), true);
        http_response_code($response['status']);
        
        foreach ($response['headers'] as $key => $value) {
            header("{$key}: {$value}");
        }
        echo $response['body'];
        
        // Clean up files
        unlink("./requests/{$requestId}.json");
        unlink("./responses/{$requestId}.json");
        exit;
    }
    sleep(1);
}

// If timeout, return request ID for client to poll later
http_response_code(202);
echo json_encode(['request_id' => $requestId]);

2. Local Polling Endpoint (local_poll.php) #

This script lets your local program fetch pending requests:

<?php
// Get all pending request files
$requestFiles = glob("./requests/*.json");
$requests = [];

foreach ($requestFiles as $file) {
    $requestId = basename($file, '.json');
    $requests[$requestId] = json_decode(file_get_contents($file), true);
}

echo json_encode($requests);

3. Response Submission Endpoint (submit_response.php) #

This script accepts responses from your local program and stores them for the client:

<?php
$responseData = json_decode(file_get_contents('php://input'), true);

if (empty($responseData['request_id'])) {
    http_response_code(400);
    echo "Missing request ID";
    exit;
}

$requestId = $responseData['request_id'];
unset($responseData['request_id']);

file_put_contents("./responses/{$requestId}.json", json_encode($responseData));
http_response_code(200);
echo "Response saved successfully";

4. Local Program Example (Python) #

This script runs on your local machine, polls for requests, forwards them to your local server, and sends back responses:

import requests
import time

# Configure your URLs
LOCAL_SERVICE_URL = "http://localhost:8080"  # Your local server
REMOTE_POLL_URL = "http://your-host.com/local_poll.php"
REMOTE_SUBMIT_URL = "http://your-host.com/submit_response.php"

def forward_request(request_id, request_data):
    try:
        # Clean up headers that might cause conflicts
        headers = request_data['headers']
        headers.pop('Host', None)
        
        # Forward request to local service
        response = requests.request(
            method=request_data['method'],
            url=LOCAL_SERVICE_URL,
            headers=headers,
            data=request_data['body']
        )
        
        # Prepare and submit response to remote PHP
        response_payload = {
            'request_id': request_id,
            'status': response.status_code,
            'headers': dict(response.headers),
            'body': response.text
        }
        requests.post(REMOTE_SUBMIT_URL, json=response_payload)
        print(f"Processed request {request_id} successfully")
    except Exception as e:
        print(f"Failed to process request {request_id}: {str(e)}")

if __name__ == "__main__":
    while True:
        try:
            # Poll for pending requests
            poll_response = requests.get(REMOTE_POLL_URL)
            pending_requests = poll_response.json()
            
            for req_id, req_data in pending_requests.items():
                forward_request(req_id, req_data)
        except Exception as e:
            print(f"Polling failed: {str(e)}")
        time.sleep(1)  # Poll every second

• PHP Execution Limits: Most shared hosts cap PHP execution time at 30-60 seconds. The long-polling script uses a 30-second timeout to stay within this.
• File Locking: For high-concurrency scenarios, add file locking with flock() to prevent race conditions when reading/writing request files.
• Security: Add API keys or authentication to your PHP endpoints to block malicious requests. Never forward unfiltered requests to your local server—validate and sanitize inputs.
• Performance: This approach is best for low-traffic use cases. For higher volume, swap file storage for a Redis database or MySQL (if your host supports it) for faster, more reliable access.
• Local Network Access: Since your local program initiates connections to the remote host, you don't need port forwarding on your local router.

内容的提问来源于stack exchange，提问作者armando