Прервать загрузку HTTP-файла с сервера PHP или Apache

прежде всего,вы можете попробовать этот код самостоятельно, используя репозиторий GitHub, который я создал для этого. Просто клонируйте репозиторий и запустите node header.

(спойлер, если Вы читаете это и находитесь под давлением времени, чтобы заставить что-то работать, а не в настроении учиться (: (), есть более простое решение в конце)

общая идея

это большой вопрос. То, что вы просите, это вполне возможно и нет клиентские необходимо, просто более глубокое понимание того, как работает протокол HTTP, показывая, как узел.Яш камни :)

это можно сделать легко, если мы пойдем на один уровень глубже к основному протокол TCP и обрабатывать HTTP-запросы для этого конкретного случая. Узел.js позволяет сделать это легко, используя встроенный объем модуля.

протокол HTTP

во-первых, давайте посмотрим, как HTTP-запросы работа.

HTTP-запрос состоит из раздела заголовков в общем формате пар ключ: значение, разделенных CRLF (\r\n). Мы знаем, что раздел заголовка закончился, когда мы достигли двойного CRLF (то есть \r\n\r\n).

типичный запрос HTTP GET может выглядеть примерно так:

GET /resource HTTP/1.1  
Cache-Control: no-cache  
User-Agent: Mozilla/5.0 

Hello=World&stuff=other

верхняя часть перед "пустой строкой" - это раздел заголовков, а нижняя часть-тело запроса. Ваш запрос будет выглядеть немного по-разному в разделе тела, так как он закодирован с multipart/form-data а заголовок останется similarLet рассмотрим, как это относится к нам.

TCP в nodejs

мы можем слушать необработанный запрос в TCP и читать пакеты, которые мы получаем, пока не прочитаем тот двойной crlf, о котором мы говорили. Затем мы проверим короткий раздел заголовка, который у нас уже есть для любой проверки, которая нам нужна. После этого мы можем либо завершить запрос, если проверка не прошла (например, просто завершение TCP-соединения), или передать его через. Это позволяет нам не получать или читать тело запроса, а только заголовки, которые намного меньше.

один простой способ встроить это в уже существующее приложение-это прокси-запросы от него к фактическому http-серверу для конкретного случая использования.

детали реализации

данное решение как голые кости как получится. Это просто предложение.

здесь рабочий поток:

1. нам требуется net модуль в узле.js, который позволяет нам создавать tcp-серверы в узле.js

2. создайте TCP-сервер с помощью net модуль, который будет слушать данные:var tcpServer = net.createServer(function (socket) {... . Не забудьте сказать ему, чтобы слушать правильный порт

   • внутри этого обратного вызова слушайте события данных socket.on("data",function(data){, который будет срабатывать всякий раз, когда приходит пакет.
   • прочитайте данные пройденного буфер из события "data" и сохраните его в переменной
   • проверьте наличие двойного CRLF, это гарантирует, что раздел заголовка запроса закончился согласно протоколу HTTP
   • предполагая, что проверка является заголовком (токен в ваших словах), проверьте его после разбора просто заголовки, (то есть мы получили двойной CRLF). Это также работает при проверке заголовка content-length.
   • если вы заметили, что заголовки не проверьте, позвоните socket.end() который закроет соединение.

вот некоторые вещи, которые мы будем использовать

метод чтения заголовков:

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 в буфере, который вы получаете на событии данных, и возвращаете его местоположение, если он существует в объекте:

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) { //\r
            if (data[i + 1] === 10) { //\n
                if (i + 3 < data.length && data[i + 2] === 13 && data[i + 3] === 10) {
                    return { loc: i, after: i + 4 };
                }
            }
        } else if (data[i] === 10) { //\n

            if (data[i + 1] === 10) { //\n
                return { loc: i, after: i + 2 };
            }
        }
    }    
    return { loc: -1, after: -1337 };
};

и этот небольшой метод полезности:

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

реализация

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("\r\n");
            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

если у вас есть какие-либо вопросы не стесняйтесь задавать :)

хорошо, я солгал, есть более простой способ!

но что в этом забавного? Если вы пропустили здесь изначально, вы не узнаете, как работает HTTP:)

узел.js имеет встроенный http модуль. Поскольку запросы разделены по природе в node.js, особенно длинные запросы, вы можете реализовать то же самое без более глубокого понимания протокола.

на этот раз, давайте использовать http модуль для создания http-сервер

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);

это основано на факте request ручка в nodejs http модуль фактически подключается после отправки заголовков (но больше ничего не было выполнено) по умолчанию. (это в серверном модуле , это в модуле парсера)

пользователей igorw предложил несколько более чистое решение, используя 100 Continue заголовок, предполагающий, что браузеры, на которые вы нацелены, поддерживают его. 100 ПРОДОЛЖИТЬ является ли код состояния разработан, чтобы сделать именно то, что вы пытаетесь:

цель статуса 100 (ПРОДОЛЖИТЬ) (см. раздел 10.1.1) состоит в том, чтобы клиент, который отправляет сообщение запроса в теле запроса чтобы определить, готов ли исходный сервер принять запрос (на основе заголовков запроса) перед отправкой запроса клиентом тело. В некоторых случаях это может быть либо неуместно, либо крайне неэффективно для клиента отправлять тело, если сервер отклонит сообщение, не глядя на тело.

вот это :

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);

вы можете увидеть образец ввода / вывода здесь. Для этого потребуется ваша просьба стрелять с соответствующим .