Differential D20975 Diff 49975 src/aphront/multipartparser/AphrontMultipartParser.php

Changeset View

Standalone View

src/aphront/multipartparser/AphrontMultipartParser.php

This file was added.

				<?php

				final class AphrontMultipartParser extends Phobject {

				private $contentType;
				private $boundary;

				private $buffer;
				private $body;
				private $state;

				private $part;
				private $parts;

				public function setContentType($content_type) {
				$this->contentType = $content_type;
				return $this;
				}

				public function getContentType() {
				return $this->contentType;
				}

				public function beginParse() {
				$content_type = $this->getContentType();
				if ($content_type === null) {
				throw new PhutilInvalidStateException('setContentType');
				}

				if (!preg_match('(^multipart/form-data)', $content_type)) {
				throw new Exception(
				pht(
				'Expected "multipart/form-data" content type when executing a '.
				'multipart body read.'));
				}

				$type_parts = preg_split('(\s;\s)', $content_type);
				$boundary = null;
				foreach ($type_parts as $type_part) {
				$matches = null;
				if (preg_match('(^boundary=(.*))', $type_part, $matches)) {
				$boundary = $matches[1];
				break;
				}
				}

				if ($boundary === null) {
				throw new Exception(
				pht('Received "multipart/form-data" request with no "boundary".'));
				}

				$this->parts = array();
				$this->part = null;

				$this->buffer = '';
				$this->boundary = $boundary;

				// We're looking for a (usually empty) body before the first boundary.
				$this->state = 'bodynewline';
				}

				public function continueParse($bytes) {
				$this->buffer .= $bytes;

				$continue = true;
				while ($continue) {
				switch ($this->state) {
				case 'endboundary':
				// We've just parsed a boundary. Next, we expect either "--" (which
				// indicates we've reached the end of the parts) or "\r\n" (which
				// indicates we should read the headers for the next part).

				if (strlen($this->buffer) < 2) {
				// We don't have enough bytes yet, so wait for more.
				$continue = false;
				break;
				}

				if (!strncmp($this->buffer, '--', 2)) {
				// This is "--" after a boundary, so we're done. We'll read the
				// rest of the body (the "epilogue") and discard it.
				$this->buffer = substr($this->buffer, 2);
				$this->state = 'epilogue';

				$this->part = null;
				break;
				}

				if (!strncmp($this->buffer, "\r\n", 2)) {
				// This is "\r\n" after a boundary, so we're going to going to
				// read the headers for a part.
				$this->buffer = substr($this->buffer, 2);
				$this->state = 'header';

				// Create the object to hold the part we're about to read.
				$part = new AphrontMultipartPart();
				$this->parts[] = $part;
				$this->part = $part;
				break;
				}

				throw new Exception(
				pht('Expected "\r\n" or "--" after multipart data boundary.'));
				case 'header':
				// We've just parsed a boundary, followed by "\r\n". We are going
				// to read the headers for this part. They are in the form of HTTP
				// headers and terminated by "\r\n". The section is terminated by
				// a line with no header on it.

				if (strlen($this->buffer) < 2) {
				// We don't have enough data to find a "\r\n", so wait for more.
				$continue = false;
				break;
				}

				if (!strncmp("\r\n", $this->buffer, 2)) {
				// This line immediately began "\r\n", so we're done with parsing
				// headers. Start parsing the body.
				$this->buffer = substr($this->buffer, 2);
				$this->state = 'body';
				break;
				}

				// This is an actual header, so look for the end of it.
				$header_len = strpos($this->buffer, "\r\n");
				if ($header_len === false) {
				// We don't have a full header yet, so wait for more data.
				$continue = false;
				break;
				}

				$header_buf = substr($this->buffer, 0, $header_len);
				$this->part->appendRawHeader($header_buf);

				$this->buffer = substr($this->buffer, $header_len + 2);
				break;
				case 'body':
				// We've parsed a boundary and headers, and are parsing the data for
				// this part. The data is terminated by "\r\n--", then the boundary.

				// We'll look for "\r\n", then switch to the "bodynewline" state if
				// we find it.

				$marker = "\r";
				$marker_pos = strpos($this->buffer, $marker);

				if ($marker_pos === false) {
				// There's no "\r" anywhere in the buffer, so we can just read it
				// as provided. Then, since we read all the data, we're done until
				// we get more.

				// Note that if we're in the preamble, we won't have a "part"
				// object and will just discard the data.
				if ($this->part) {
				$this->part->appendData($this->buffer);
				}
				$this->buffer = '';
				$continue = false;
				break;
				}

				if ($marker_pos > 0) {
				// If there are bytes before the "\r",
				if ($this->part) {
				$this->part->appendData(substr($this->buffer, 0, $marker_pos));
				}
				$this->buffer = substr($this->buffer, $marker_pos);
				}

				$expect = "\r\n";
				$expect_len = strlen($expect);
				if (strlen($this->buffer) < $expect_len) {
				// We don't have enough bytes yet to know if this is "\r\n"
				// or not.
				$continue = false;
				break;
				}

				if (strncmp($this->buffer, $expect, $expect_len)) {
				// The next two bytes aren't "\r\n", so eat them and go looking
				// for more newlines.
				if ($this->part) {
				$this->part->appendData(substr($this->buffer, 0, $expect_len));
				}
				$this->buffer = substr($this->buffer, $expect_len);
				break;
				}

				// Eat the "\r\n".
				$this->buffer = substr($this->buffer, $expect_len);
				$this->state = 'bodynewline';
				break;
				case 'bodynewline':
				// We've parsed a newline in a body, or we just started parsing the
				// request. In either case, we're looking for "--", then the boundary.
				// If we find it, this section is done. If we don't, we consume the
				// bytes and move on.

				$expect = '--'.$this->boundary;
				$expect_len = strlen($expect);

				if (strlen($this->buffer) < $expect_len) {
				// We don't have enough bytes yet, so wait for more.
				$continue = false;
				break;
				}

				if (strncmp($this->buffer, $expect, $expect_len)) {
				// This wasn't the boundary, so return to the "body" state and
				// consume it. (But first, we need to append the "\r\n" which we
				// ate earlier.)
				if ($this->part) {
				$this->part->appendData("\r\n");
				}
				$this->state = 'body';
				break;
				}

				// This is the boundary, so toss it and move on.
				$this->buffer = substr($this->buffer, $expect_len);
				$this->state = 'endboundary';
				break;
				case 'epilogue':
				// We just discard any epilogue.
				$this->buffer = '';
				$continue = false;
				break;
				default:
				throw new Exception(
				pht(
				'Unknown parser state "%s".\n',
				$this->state));
				}
				}
				}

				public function endParse() {
				if ($this->state !== 'epilogue') {
				throw new Exception(
				pht(
				'Expected "multipart/form-data" parse to end '.
				'in state "epilogue".'));
				}

				return $this->parts;
				}


				}