public function filter($in, $out, &$consumed, $closing) { while ($bucket = stream_bucket_make_writeable($in)) { if (!empty($this->_previous)) { $bucket->data = $this->_previous . $bucket->data; $this->_previous = ''; } if (!feof($this->stream) && preg_match('/(%[12]\\$|%[12]|%)$/', $bucket->data)) { $this->_previous .= $bucket->data; return PSFS_FEED_ME; } $consumed += $bucket->datalen; if (preg_match('/%([12])\\$s/', $bucket->data, $matches)) { if ($matches[1] == '1') { $bucket->data = preg_replace('/%1\\$s/', $this->_sender, $bucket->data); } else { $bucket->data = preg_replace('/%2\\$s/', $this->_recipient, $bucket->data); } } $bucket->datalen = strlen($bucket->data); stream_bucket_append($out, $bucket); } if (!empty($this->_previous)) { if ($closing) { $bucket = stream_bucket_new($this->stream, $this->_previous); $bucket->data = $this->_previous; $consumed += strlen($this->_previous); $this->_previous = ''; stream_bucket_append($out, $bucket); } } return PSFS_PASS_ON; }
public function filter($in, $out, &$consumed, $closing) : int { while ($bucket = stream_bucket_make_writeable($in)) { stream_bucket_append($out, stream_bucket_new($this->stream, str_rot13($bucket->data))); } return \PSFS_PASS_ON; }
function filter($in, $out, &$consumed, $closing) { while ($bucket = stream_bucket_make_writeable($in)) { $this->data .= $bucket->data; $this->bucket = $bucket; $consumed = 0; } if ($closing) { $consumed += strlen($this->data); if (isset($this->bucket)) { $bucket = $this->bucket; } else { $bucket = stream_bucket_new($this->stream, ''); } $f = self::$registry[get_class($this)]; AbstractStreamProcessor__lazyUriResolver::bind($this->stream, $f->uri); $bucket->data = $f->process($this->data); $bucket->datalen = strlen($bucket->data); stream_bucket_append($out, $bucket); $this->bucket = null; $this->data = ''; return PSFS_PASS_ON; } return PSFS_FEED_ME; }
function filter($in, $out, &$consumed, $closing) { if (!$closing) { $bucket = stream_bucket_new($this->stream, "42"); } return PSFS_ERR_FATAL; }
/** * Filter some data. * * @param resource $in Read from this input stream * @param resource $out Write to this output stream * @param int $consumed Count of bytes processed * @param bool $closing Is the input about to end? * * @return int PSFS_PASS_ON / PSFS_FEED_ME / PSFS_ERR_FATAL */ public function filter($in, $out, &$consumed, $closing) : int { $return = PSFS_FEED_ME; // While input data is available, continue to read it. while ($bucket_in = stream_bucket_make_writeable($in)) { $this->data .= $bucket_in->data; $consumed += $bucket_in->datalen; // While we have complete GEDCOM records, process them. while (preg_match('/(.*?[\\r\\n]\\s*)(0.*)/s', $this->data, $match) === 1) { list(, $data, $this->data) = $match; // Send this record output. $data = $this->filterData($data); $bucket_out = stream_bucket_new($this->stream, $data); $return = PSFS_PASS_ON; stream_bucket_append($out, $bucket_out); } } // Process the final record. if ($closing && $this->data !== '') { $data = $this->filterData($this->data); $bucket_out = stream_bucket_new($this->stream, $data); $return = PSFS_PASS_ON; stream_bucket_append($out, $bucket_out); } return $return; }
function filter($in, $out, &$consumed, $closing) { while ($ib = stream_bucket_make_writeable($in)) { $ob = stream_bucket_new($this->stream, strtoupper($ib->data)); stream_bucket_append($out, $ob); } return PSFS_PASS_ON; }
/** * @see stream_filter_register() */ public function filter($in, $out, &$consumed, $closing) { stream_bucket_append($out, stream_bucket_new($this->stream, '"')); while ($bucket = stream_bucket_make_writeable($in)) { $consumed += $bucket->datalen; $bucket->data = addcslashes($bucket->data, '"\\'); stream_bucket_append($out, $bucket); } stream_bucket_append($out, stream_bucket_new($this->stream, '"')); return PSFS_PASS_ON; }
public function filter($in, $out, &$consumed, $closing) { while ($bucket = stream_bucket_make_writeable($in)) { $this->buffer .= $bucket->data; $consumed += $bucket->datalen; } if ($closing) { $bucket = stream_bucket_new($this->stream, 'Closed: ' . $this->buffer); stream_bucket_append($out, $bucket); } return PSFS_PASS_ON; }
public function filter($in, $out, &$consumed, $closing) { while ($bucket = stream_bucket_make_writeable($in)) { $lenbucket = stream_bucket_new($this->stream, dechex($bucket->datalen) . "\r\n"); stream_bucket_append($out, $lenbucket); $consumed += $bucket->datalen; stream_bucket_append($out, $bucket); $lenbucket = stream_bucket_new($this->stream, "\r\n"); stream_bucket_append($out, $lenbucket); } return PSFS_PASS_ON; }
public function filter($in, $out, &$consumed, $closing) { // concatenate whole buffer from input brigade $data = ''; while ($bucket = stream_bucket_make_writeable($in)) { $consumed += $bucket->datalen; $data .= $bucket->data; } // skip processing callback that already ended if ($this->closed) { return PSFS_FEED_ME; } // only invoke filter function if buffer is not empty // this may skip flushing a closing filter if ($data !== '') { try { $data = call_user_func($this->callback, $data); } catch (Exception $e) { // exception should mark filter as closed $this->onClose(); trigger_error('Error invoking filter: ' . $e->getMessage(), E_USER_WARNING); return PSFS_ERR_FATAL; } } // mark filter as closed after processing closing chunk if ($closing) { $this->closed = true; // callback supports closing and is not already closed if ($this->supportsClose) { $this->supportsClose = false; // invoke without argument to signal end and append resulting buffer try { $data .= call_user_func($this->callback); } catch (Exception $e) { trigger_error('Error ending filter: ' . $e->getMessage(), E_USER_WARNING); return PSFS_ERR_FATAL; } } } if ($data !== '') { // create a new bucket for writing the resulting buffer to the output brigade // reusing an existing bucket turned out to be bugged in some environments (ancient PHP versions and HHVM) $bucket = @stream_bucket_new($this->stream, $data); // legacy PHP versions (PHP < 5.4) do not support passing data from the event signal handler // because closing the stream invalidates the stream and its stream bucket brigade before // invoking the filter close handler. if ($bucket !== false) { stream_bucket_append($out, $bucket); } } return PSFS_PASS_ON; }
/** * Filter implementation converts encoding before returning PSFS_PASS_ON. * * @param resource $in * @param resource $out * @param int $consumed * @param bool $closing * @return int */ public function filter($in, $out, &$consumed, $closing) { while ($bucket = stream_bucket_make_writeable($in)) { $converted = $this->converter->convert($bucket->data); $consumed += strlen($bucket->data); // $this->stream is undocumented. It was found looking at HHVM's source code // for its convert.iconv.* implementation in ConvertIconFilter and explained // somewhat in this StackOverflow page: http://stackoverflow.com/a/31132646/335059 // declaring a member variable called 'stream' breaks the PHP implementation (5.5.9 // at least). stream_bucket_append($out, stream_bucket_new($this->stream, $converted)); } return PSFS_PASS_ON; }
public function filter($in, $out, &$consumed, $closing) { static $closed = 0; while ($bucket = stream_bucket_make_writeable($in)) { stream_bucket_append($out, stream_bucket_new($this->stream, $bucket->data)); } if ($closing) { $closed++; } if ($closed > 0) { var_dump($closed++); } return PSFS_PASS_ON; }
/** * {@inheritdoc} */ public function filter($in, $out, &$consumed, $closing) { while ($streamBucket = stream_bucket_make_writeable($in)) { $this->sourceCode .= $streamBucket->data; } if ($closing || feof($this->stream)) { $consumed = strlen($this->sourceCode); $processedCode = Engine::parse($this->sourceCode); $streamBucket = stream_bucket_new($this->stream, $processedCode); stream_bucket_append($out, $streamBucket); return PSFS_PASS_ON; } return PSFS_FEED_ME; }
/** * @param resource $in * @param resource $out * @param int $consumed * @param bool $closing * * @return int */ public function filter($in, $out, &$consumed, $closing) { if ($closing) { /** @var resource|\stdClass $bucket */ $bucket = stream_bucket_new($this->stream, $this->transform($this->data)); $this->data = ''; $consumed += $bucket->datalen; stream_bucket_append($out, $bucket); return PSFS_PASS_ON; } else { while ($bucket = stream_bucket_make_writeable($in)) { $this->data .= $bucket->data; } return PSFS_FEED_ME; } }
function filter($in, $out, &$consumed, $closing) { $output = 0; while ($bucket = stream_bucket_make_writeable($in)) { $bucket->data = strtoupper($bucket->data); $consumed += $bucket->datalen; stream_bucket_append($out, $bucket); $output = 1; } if ($closing) { $bucket = stream_bucket_new($this->stream, "\n===close===\n"); stream_bucket_append($out, $bucket); $output = 1; } return $output ? PSFS_PASS_ON : PSFS_FEED_ME; }
/** * @see stream_filter_register() */ public function filter($in, $out, &$consumed, $closing) { if (!$this->_prepend) { stream_bucket_append($out, stream_bucket_new($this->stream, '"')); $this->_prepend = true; } while ($bucket = stream_bucket_make_writeable($in)) { $consumed += $bucket->datalen; $bucket->data = addcslashes($bucket->data, '"\\'); stream_bucket_append($out, $bucket); } /* feof() call needed due to: * http://news.php.net/php.internals/80363 */ if ($closing || feof($this->stream)) { stream_bucket_append($out, stream_bucket_new($this->stream, '"')); } return PSFS_PASS_ON; }
public function filter($in, $out, &$consumed, $closing) { $type = $this->type; $ret = PSFS_FEED_ME; while ($bucket = stream_bucket_make_writeable($in)) { $consumed += $bucket->datalen; $this->buffer .= $bucket->data; } if ($type == 'enrypt') { $blockSize = $this->crypter->getEncryptBlockSize(); } else { $blockSize = $this->crypter->getDecryptBlockSize(); } if ($blockSize < 1) { // stream cipher or special cases, encrypt every bucket $blockSize = 1; } $len = strlen($this->buffer); // process filled blocks if ($blockSize > 0 and $len >= $blockSize) { $mod = $len % $blockSize; $data = $this->crypter->{$type}(substr($this->buffer, 0, $len - $mod)); $this->buffer = substr($this->buffer, $len - $mod); $bucket = stream_bucket_new($this->temp, $data); if ($bucket === false) { return PSFS_ERR_FATAL; } stream_bucket_append($out, $bucket); $ret = PSFS_PASS_ON; } // process rest data if we are closing if ($closing and strlen($this->buffer) > 0) { $bucket = stream_bucket_new($this->temp, $this->crypter->{$type}($this->buffer)); if ($bucket === false) { return PSFS_ERR_FATAL; } $this->buffer = ''; stream_bucket_append($out, $bucket); $ret = PSFS_PASS_ON; } return $ret; }
/** * Filter the input data through the transform. * * @param resource $input The input bucket brigade. * @param resource $output The output bucket brigade. * @param integer &$consumed The number of bytes consumed. * @param boolean $isEnd True if the stream is closing. * * @return integer The result code. */ public function filter($input, $output, &$consumed, $isEnd) { $bucket = stream_bucket_make_writeable($input); if ($isEnd && !$bucket) { $bucket = stream_bucket_new(STDIN, ''); } $hasOutput = false; while ($bucket) { $this->buffer .= $bucket->data; $bufferSize = strlen($this->buffer); if (!$isEnd && $bufferSize < $this->bufferSize) { $bucket = stream_bucket_make_writeable($input); continue; } list($outputBuffer, $thisConsumed, $error) = $this->transform->transform($this->buffer, $this->context, $isEnd); $consumed += $thisConsumed; if ($bufferSize === $thisConsumed) { $this->buffer = ''; } else { $this->buffer = substr($this->buffer, $thisConsumed); } if ('' !== $outputBuffer) { $bucket->data = $outputBuffer; stream_bucket_append($output, $bucket); $hasOutput = true; } if (null !== $error) { return PSFS_ERR_FATAL; } $bucket = stream_bucket_make_writeable($input); } if ($hasOutput || $isEnd) { return PSFS_PASS_ON; } return PSFS_FEED_ME; }
/** * Create a new bucket for use on the current stream * * @param resource $stream * @param string $buffer * * @return object */ public function bucketNew($stream, string $buffer) { return stream_bucket_new($stream, $buffer); }
/** * {@inheritdoc} */ public function filter($in, $out, &$consumed, $closing) { while ($bucket = stream_bucket_make_writeable($in)) { $this->data .= $bucket->data; } if ($closing || feof($this->stream)) { $consumed = strlen($this->data); // $this->stream contains pointer to the source $metadata = new StreamMetaData($this->stream, $this->data); $this->transformCode($metadata); $bucket = stream_bucket_new($this->stream, $metadata->source); stream_bucket_append($out, $bucket); return PSFS_PASS_ON; } return PSFS_FEED_ME; }
public function filter($in, $out, &$consumed, $closing) { $bucket = stream_bucket_new(fopen('php://temp', 'w+'), ''); stream_bucket_append($out, $bucket); return PSFS_PASS_ON; }
function filter($in, $out, &$consumed, $closing) { $bucket = stream_bucket_new(fopen('php://memory', 'wb'), self::$buf); stream_bucket_append($out, $bucket); return PSFS_PASS_ON; }
/** * Set a brigade. * If a stream is given (with the constant self::IS_A_STREAM), it will * create a brigade automatically. * * @param resource &$brigade A stream or a brigade. * @param bool $is Specify if $brigade is a stream or a * brigade, given by self::IS_A_* constant. * @param string $buffer Stream buffer. * @return void */ public function __construct(&$brigade, $is = self::IS_A_BRIGADE, $buffer = '') { $this->setType($is); if (self::IS_A_BRIGADE === $this->getType()) { $this->setBrigade($brigade); } else { $this->setBucket(stream_bucket_new($brigade, $buffer)); $bucket = $this->getBucket(); $this->setBrigade($bucket); } return; }
/** * Alias for @stream_bucket_create * @param resource $stream * @param string $buffer */ public static function create($stream, $buffer) { return stream_bucket_new($stream, $buffer); }