Handle 'Content-Length' requests

src/LengthLimitedStream.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace React\Http;
+
+use Evenement\EventEmitter;
+use React\Stream\ReadableStreamInterface;
+use React\Stream\WritableStreamInterface;
+use React\Stream\Util;
+
+/** @internal */
+class LengthLimitedStream extends EventEmitter implements ReadableStreamInterface
+{
+    private $stream;
+    private $closed = false;
+    private $encoder;
+    private $transferredLength = 0;
+    private $maxLength;
+
+    public function __construct(ReadableStreamInterface $stream, $maxLength)
+    {
+        $this->stream = $stream;
+        $this->maxLength = $maxLength;
+
+        $this->stream->on('data', array($this, 'handleData'));
+        $this->stream->on('end', array($this, 'handleEnd'));
+        $this->stream->on('error', array($this, 'handleError'));
+        $this->stream->on('close', array($this, 'close'));
+    }
+
+    public function isReadable()
+    {
+        return !$this->closed && $this->stream->isReadable();
+    }
+
+    public function pause()
+    {
+        $this->stream->pause();
+    }
+
+    public function resume()
+    {
+        $this->stream->resume();
+    }
+
+    public function pipe(WritableStreamInterface $dest, array $options = array())
+    {
+        Util::pipe($this, $dest, $options);
+
+        return $dest;
+    }
+
+    public function close()
+    {
+        if ($this->closed) {
+            return;
+        }
+
+        $this->closed = true;
+
+        $this->stream->close();
+
+        $this->emit('close');
+        $this->removeAllListeners();
+    }
+
+    /** @internal */
+    public function handleData($data)
+    {
+        if (($this->transferredLength + strlen($data)) > $this->maxLength) {
+            // Only emit data until the value of 'Content-Length' is reached, the rest will be ignored
+            $data = (string)substr($data, 0, $this->maxLength - $this->transferredLength);
+        }
+
+        if ($data !== '') {
+            $this->transferredLength += strlen($data);
+            $this->emit('data', array($data));
+        }
+
+        if ($this->transferredLength === $this->maxLength) {
+            // 'Content-Length' reached, stream will end
+            $this->emit('end');
+            $this->close();
+            $this->stream->removeListener('data', array($this, 'handleData'));
+        }
+    }
+
+    /** @internal */
+    public function handleError(\Exception $e)
+    {
+        $this->emit('error', array($e));
+        $this->close();
+    }
+
+    /** @internal */
+    public function handleEnd()
+    {
+        if (!$this->closed) {
+            $this->handleError(new \Exception('Unexpected end event'));
+        }
+    }
+
+}

src/Server.php

@@ -153,6 +153,17 @@ public function handleRequest(ConnectionInterface $conn, Request $request)
             if (strtolower(end($transferEncodingHeader)) === 'chunked') {
                 $stream = new ChunkedDecoder($conn);
             }
+        } elseif ($request->hasHeader('Content-Length')) {
+            $string = $request->getHeaderLine('Content-Length');
+
+            $contentLength = (int)$string;
+            if ((string)$contentLength !== (string)$string) {
+                // Content-Length value is not an integer or not a single integer
+                $this->emit('error', array(new \InvalidArgumentException('The value of `Content-Length` is not valid')));
+                return $this->writeError($conn, 400);
+            }
+
+            $stream = new LengthLimitedStream($conn, $contentLength);
         }
 
         // forward pause/resume calls to underlying connection
@@ -173,6 +184,13 @@ public function handleRequest(ConnectionInterface $conn, Request $request)
         });
 
         $this->emit('request', array($request, $response));
+
+        if ($stream instanceof LengthLimitedStream && $contentLength === 0) {
+            // Content-Length is 0 and won't emit further data,
+            // 'handleData' from LengthLimitedStream won't be called anymore
+            $stream->emit('end');
+            $stream->close();
+        }
     }
 
     /** @internal */

tests/LengthLimitedStreamTest.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace React\Tests\Http;
+
+use React\Http\LengthLimitedStream;
+use React\Stream\ReadableStream;
+
+class LengthLimitedStreamTest extends TestCase
+{
+    private $input;
+    private $stream;
+
+    public function setUp()
+    {
+        $this->input = new ReadableStream();
+    }
+
+    public function testSimpleChunk()
+    {
+        $stream = new LengthLimitedStream($this->input, 5);
+        $stream->on('data', $this->expectCallableOnceWith('hello'));
+        $stream->on('end', $this->expectCallableOnce());
+        $this->input->emit('data', array("hello world"));
+    }
+
+    public function testInputStreamKeepsEmitting()
+    {
+        $stream = new LengthLimitedStream($this->input, 5);
+        $stream->on('data', $this->expectCallableOnceWith('hello'));
+        $stream->on('end', $this->expectCallableOnce());
+
+        $this->input->emit('data', array("hello world"));
+        $this->input->emit('data', array("world"));
+        $this->input->emit('data', array("world"));
+    }
+
+    public function testZeroLengthInContentLengthWillIgnoreEmittedDataEvents()
+    {
+        $stream = new LengthLimitedStream($this->input, 0);
+        $stream->on('data', $this->expectCallableNever());
+        $stream->on('end', $this->expectCallableOnce());
+        $this->input->emit('data', array("hello world"));
+    }
+
+    public function testHandleError()
+    {
+        $stream = new LengthLimitedStream($this->input, 0);
+        $stream->on('error', $this->expectCallableOnce());
+        $stream->on('close', $this->expectCallableOnce());
+
+        $this->input->emit('error', array(new \RuntimeException()));
+
+        $this->assertFalse($stream->isReadable());
+    }
+
+    public function testPauseStream()
+    {
+        $input = $this->getMockBuilder('React\Stream\ReadableStreamInterface')->getMock();
+        $input->expects($this->once())->method('pause');
+
+        $stream = new LengthLimitedStream($input, 0);
+        $stream->pause();
+    }
+
+    public function testResumeStream()
+    {
+        $input = $this->getMockBuilder('React\Stream\ReadableStreamInterface')->getMock();
+        $input->expects($this->once())->method('pause');
+
+        $stream = new LengthLimitedStream($input, 0);
+        $stream->pause();
+        $stream->resume();
+    }
+
+    public function testPipeStream()
+    {
+        $stream = new LengthLimitedStream($this->input, 0);
+        $dest = $this->getMockBuilder('React\Stream\WritableStreamInterface')->getMock();
+
+        $ret = $stream->pipe($dest);
+
+        $this->assertSame($dest, $ret);
+    }
+
+    public function testHandleClose()
+    {
+        $stream = new LengthLimitedStream($this->input, 0);
+        $stream->on('close', $this->expectCallableOnce());
+
+        $this->input->close();
+        $this->input->emit('end', array());
+
+        $this->assertFalse($stream->isReadable());
+    }
+
+    public function testOutputStreamCanCloseInputStream()
+    {
+        $input = new ReadableStream();
+        $input->on('close', $this->expectCallableOnce());
+
+        $stream = new LengthLimitedStream($input, 0);
+        $stream->on('close', $this->expectCallableOnce());
+
+        $stream->close();
+
+        $this->assertFalse($input->isReadable());
+    }
+
+    public function testHandleUnexpectedEnd()
+    {
+        $stream = new LengthLimitedStream($this->input, 5);
+
+        $stream->on('data', $this->expectCallableNever());
+        $stream->on('close', $this->expectCallableOnce());
+        $stream->on('end', $this->expectCallableNever());
+        $stream->on('error', $this->expectCallableOnce());
+
+        $this->input->emit('end');
+    }
+}