通过 PHP 或 Apache 从服务器端上传 HTTP 文件

Create a TCP server using the net module which will listen to data: var tcpServer = net.createServer(function (socket) {... . Don't forget to tell it to listen to the correct port

• 在该回调中，侦听数据事件 socket.on("data",function(data){ ，每当数据包到达时就会触发.
• 从 'data' 事件中读取传递缓冲区的数据，并将其存储在一个变量中
• 检查双 CRLF，这确保请求 HEADER 部分已经结束 根据HTTP 协议
• 假设验证是一个标头(用你的话来说是令牌)在解析只是标头后检查它，(也就是说，我们得到了双 CRLF).这在检查内容长度标头时也有效.
• 如果您发现标头未检出，请调用 socket.end() 以关闭连接.
• Inside that callback, listen to data events socket.on("data",function(data){ , which will trigger whenever a packet arrives.
• read the data of the passed buffer from the 'data' event, and store that in a variable
• check for double CRLF, this ensures that the request HEADER section has ended according to the HTTP protocol
• Assuming that the validation is a header (token in your words) check it after parsing just the headers , (that is, we got the double CRLF). This also works when checking for the content-length header.
• If you notice that the headers don't check out, call socket.end() which will close the connection.

读取标题的方法:

function readHeaders(headers) {
    var parsedHeaders = {};
    var previous = "";    
    headers.forEach(function (val) {
        // check if the next line is actually continuing a header from previous line
        if (isContinuation(val)) {
            if (previous !== "") {
                parsedHeaders[previous] += decodeURIComponent(val.trimLeft());
                return;
            } else {
                throw new Exception("continuation, but no previous header");
            }
        }

        // parse a header that looks like : "name: SP value".
        var index = val.indexOf(":");

        if (index === -1) {
            throw new Exception("bad header structure: ");
        }

        var head = val.substr(0, index).toLowerCase();
        var value = val.substr(index + 1).trimLeft();

        previous = head;
        if (value !== "") {
            parsedHeaders[head] = decodeURIComponent(value);
        } else {
            parsedHeaders[head] = null;
        }
    });
    return parsedHeaders;
};

一种检查数据事件缓冲区中双 CRLF 的方法，如果它存在于对象中，则返回其位置:

A method for checking double CRLF in a buffer you get on a data event, and return its location if it exists in an object:

function checkForCRLF(data) {
    if (!Buffer.isBuffer(data)) {
        data = new Buffer(data,"utf-8");
    }
    for (var i = 0; i < data.length - 1; i++) {
        if (data[i] === 13) { //
            if (data[i + 1] === 10) { //

                if (i + 3 < data.length && data[i + 2] === 13 && data[i + 3] === 10) {
                    return { loc: i, after: i + 4 };
                }
            }
        } else if (data[i] === 10) { //


            if (data[i + 1] === 10) { //

                return { loc: i, after: i + 2 };
            }
        }
    }    
    return { loc: -1, after: -1337 };
};

还有这个小实用方法:

function isContinuation(str) {
    return str.charAt(0) === " " || str.charAt(0) === "	";
}

实施

var net = require("net"); // To use the node net module for TCP server. Node has equivalent modules for secure communication if you'd like to use HTTPS

//Create the server
var server = net.createServer(function(socket){ // Create a TCP server
    var req = []; //buffers so far, to save the data in case the headers don't arrive in a single packet
    socket.on("data",function(data){
        req.push(data); // add the new buffer
        var check = checkForCRLF(data);
        if(check.loc !== -1){ // This means we got to the end of the headers!
            var dataUpToHeaders= req.map(function(x){
                return x.toString();//get buffer strings
            }).join("");
            //get data up to /r/n
            dataUpToHeaders = dataUpToHeaders.substring(0,check.after);
            //split by line
            var headerList = dataUpToHeaders.trim().split("
");
            headerList.shift() ;// remove the request line itself, eg GET / HTTP1.1
            console.log("Got headers!");
            //Read the headers
            var headerObject = readHeaders(headerList);
            //Get the header with your token
            console.log(headerObject["your-header-name"]);

            // Now perform all checks you need for it
            /*
            if(!yourHeaderValueValid){
                socket.end();
            }else{
                         //continue reading request body, and pass control to whatever logic you want!
            }
            */


        }
    });
}).listen(8080); // listen to port 8080 for the sake of the example

如果您有任何问题，请随时提问:)

If you have any questions feel free to ask :)

但这有什么好玩的?如果您最初跳过此处，您将不会了解 HTTP 的工作原理:)

But what's the fun in that? If you skipped here initially, you wouldn't learn how HTTP works :)

Node.js 有一个内置的 http 模块.由于 node.js 中的请求本质上是分块的，尤其是长请求，因此您无需更深入地了解协议即可实现相同的内容.

Node.js has a built in http module. Since requests are chunked by nature in node.js, especially long requests, you can implement the same thing without the more advanced understanding of the protocol.

这次我们使用http模块来创建一个http服务器

This time, let's use the http module to create an http server

server = http.createServer( function(req, res) { //create an HTTP server
    // The parameters are request/response objects
    // check if method is post, and the headers contain your value.
    // The connection was established but the body wasn't sent yet,
    // More information on how this works is in the above solution
    var specialRequest = (req.method == "POST") && req.headers["YourHeader"] === "YourTokenValue";
    if(specialRequest ){ // detect requests for special treatment
      // same as TCP direct solution add chunks
      req.on('data',function(chunkOfBody){
              //handle a chunk of the message body
      });
    }else{
        res.end(); // abort the underlying TCP connection, since the request and response use the same TCP connection this will work
        //req.destroy() // destroy the request in a non-clean matter, probably not what you want.
    }
}).listen(8080);

这是基于这样一个事实，nodejs http 模块中的 request 句柄在默认情况下实际上是在发送标头后挂钩的(但没有执行任何其他操作).(在服务器模块中 , 这个在解析器模块中)

This is based on the fact the request handle in a nodejs http module actually hooks on after the headers were sent (but nothing else was performed) by default. (this in the server module , this in the parser module)

用户 igorw 建议使用 100 Continue 标题假设您的目标浏览器支持它.100 Continue 是一种状态代码，旨在完全按照您的意图执行:

User igorw suggested a somewhat cleaner solution using the 100 Continue header assuming browsers you're targeting supports it. 100 Continue is a status code designed to do exactly what you're attempting to:

100(继续)状态(见第 10.1.1 节)的目的是为了允许发送带有请求正文的请求消息的客户端确定源服务器是否愿意接受请求(基于请求头)在客户端发送请求之前身体.在某些情况下，它可能不合适或高度如果服务器拒绝，客户端发送正文的效率低下不看正文的消息.

The purpose of the 100 (Continue) status (see section 10.1.1) is to allow a client that is sending a request message with a request body to determine if the origin server is willing to accept the request (based on the request headers) before the client sends the request body. In some cases, it might either be inappropriate or highly inefficient for the client to send the body if the server will reject the message without looking at the body.

这里是:

var http = require('http');
 
function handle(req, rep) {
    req.pipe(process.stdout); // pipe the request to the output stream for further handling
    req.on('end', function () {
        rep.end();
        console.log('');
    });
}
 
var server = new http.Server();
 
server.on('checkContinue', function (req, rep) {
    if (!req.headers['x-foo']) {
        console.log('did not have foo');
        rep.writeHead(400);
        rep.end();
        return;
    }
 
    rep.writeContinue();
    handle(req, rep);
});
 
server.listen(8080);

您可以在此处查看示例输入/输出.这将要求您使用适当的 Expect: 标头触发请求.

You can see sample input/output here. This would require your request to fire with the appropriate Expect: header.