/**
  * @param array $opts  Additional options:
  *   - eol: (boolean) If true, normalize EOLs in input. @since 2.2.0
  *   - skipscan: (boolean) If true, don't scan input for
  *               binary/literal/quoted data. @since 2.2.0
  */
 public function __construct($data, array $opts = array())
 {
     /* String data is stored in a stream. */
     $this->_data = new Horde_Stream_Temp();
     $this->_filter = $this->_filterParams();
     if (empty($opts['skipscan'])) {
         stream_filter_register('horde_imap_client_string', 'Horde_Imap_Client_Data_Format_Filter_String');
         $res = stream_filter_append($this->_data->stream, 'horde_imap_client_string', STREAM_FILTER_WRITE, $this->_filter);
     } else {
         $res = null;
     }
     if (empty($opts['eol'])) {
         $res2 = null;
     } else {
         stream_filter_register('horde_eol', 'Horde_Stream_Filter_Eol');
         $res2 = stream_filter_append($this->_data->stream, 'horde_eol', STREAM_FILTER_WRITE);
     }
     $this->_data->add($data);
     if (!is_null($res)) {
         stream_filter_remove($res);
     }
     if (!is_null($res2)) {
         stream_filter_remove($res2);
     }
 }

 public function testCrc32()
 {
     $filter = stream_filter_prepend($this->fp, 'horde_bin2hex', STREAM_FILTER_READ);
     rewind($this->fp);
     $this->assertEquals(bin2hex($this->testdata), stream_get_contents($this->fp));
     stream_filter_remove($filter);
 }

 /**
  * @param array $opts  Additional options:
  *   - eol: (boolean) If true, normalize EOLs in input. @since 2.2.0
  *   - skipscan: (boolean) If true, don't scan input for
  *               binary/literal/quoted data. @since 2.2.0
  *
  * @throws Horde_Imap_Client_Data_Format_Exception
  */
 public function __construct($data, array $opts = array())
 {
     /* String data is stored in a stream. */
     $this->_data = new Horde_Stream_Temp();
     if (empty($opts['skipscan'])) {
         $this->_filter = $this->_filterParams();
         stream_filter_register('horde_imap_client_string', 'Horde_Imap_Client_Data_Format_Filter_String');
         $res = stream_filter_append($this->_data->stream, 'horde_imap_client_string', STREAM_FILTER_WRITE, $this->_filter);
     } else {
         $res = null;
     }
     if (empty($opts['eol'])) {
         $res2 = null;
     } else {
         stream_filter_register('horde_eol', 'Horde_Stream_Filter_Eol');
         $res2 = stream_filter_append($this->_data->stream, 'horde_eol', STREAM_FILTER_WRITE);
     }
     $this->_data->add($data);
     if (!is_null($res)) {
         stream_filter_remove($res);
     }
     if (!is_null($res2)) {
         stream_filter_remove($res2);
     }
     if (isset($this->_filter) && $this->_filter->nonascii && !$this instanceof Horde_Imap_Client_Data_Format_String_Support_Nonascii) {
         throw new Horde_Imap_Client_Data_Format_Exception('String contains non-ASCII characters.');
     }
 }

 protected function doBackup($stream, $tables, $gzip = false)
 {
     $db = Am_Di::getInstance()->db;
     $stream_filter = null;
     $hash = null;
     $len = 0;
     if ($gzip) {
         $hash = hash_init('crc32b');
         // gzip file header
         fwrite($stream, $this->getGzHeader());
         if (!($stream_filter = stream_filter_append($stream, "zlib.deflate", STREAM_FILTER_WRITE, self::COMPRESSION_LEVEL))) {
             throw new Am_Exception_InternalError("Could not attach gzencode filter to output stream");
         }
     }
     $this->out($stream, "### aMember Pro " . AM_VERSION . " database backup\n", $len, $hash);
     $this->out($stream, "### Created: " . date('Y-m-d H:i:s') . "\n", $len, $hash);
     foreach ($tables as $table) {
         $this->out($stream, "\n\nDROP TABLE IF EXISTS {$table};\n", $len, $hash);
         $r = $db->selectRow("SHOW CREATE TABLE {$table}");
         $this->out($stream, $r['Create Table'] . ";\n", $len, $hash);
         $q = $db->queryResultOnly("SELECT * FROM {$table}");
         while ($a = $db->fetchRow($q)) {
             $fields = join(',', array_keys($a));
             $values = join(',', array_map(array($db, 'escape'), array_values($a)));
             $this->out($stream, "INSERT INTO {$table} ({$fields}) VALUES ({$values});\n", $len, $hash);
         }
         $db->freeResult($q);
     }
     if ($stream_filter) {
         stream_filter_remove($stream_filter);
         fwrite($stream, $this->getGzFooter($len, $hash));
     }
     return $stream;
 }

 public function testNull()
 {
     $filter = stream_filter_prepend($this->fp, 'horde_null', STREAM_FILTER_READ);
     rewind($this->fp);
     $this->assertEquals('abcdefghij', stream_get_contents($this->fp));
     stream_filter_remove($filter);
 }

 /**
  */
 public function __construct($data)
 {
     /* String data is stored in a stream. */
     $this->_data = new Horde_Stream_Temp();
     stream_filter_register('horde_imap_client_string', 'Horde_Imap_Client_Data_Format_Filter_String');
     $this->_filter = $this->_filterParams();
     $res = stream_filter_append($this->_data->stream, 'horde_imap_client_string', STREAM_FILTER_WRITE, $this->_filter);
     $this->_data->add($data);
     stream_filter_remove($res);
 }

 public function testCrc32()
 {
     $params = new stdClass();
     $filter = stream_filter_prepend($this->fp, 'horde_crc32', STREAM_FILTER_READ, $params);
     rewind($this->fp);
     while (fread($this->fp, 1024)) {
     }
     $this->assertObjectHasAttribute('crc32', $params);
     $this->assertEquals(crc32($this->testdata), $params->crc32);
     stream_filter_remove($filter);
 }

function test_64166($data)
{
    $fd = fopen('php://temp', 'w+');
    fwrite($fd, $data);
    rewind($fd);
    $res = stream_filter_append($fd, 'convert.quoted-printable-encode', STREAM_FILTER_READ, array('line-break-chars' => "\n", 'line-length' => 74));
    var_dump(stream_get_contents($fd, -1, 0));
    stream_filter_remove($res);
    rewind($fd);
    stream_filter_append($fd, 'convert.quoted-printable-encode', STREAM_FILTER_READ, array('line-break-chars' => "\n", 'line-length' => 6));
    var_dump(stream_get_contents($fd, -1, 0));
    fclose($fd);
}

 /**
  * Close this buffer. Flushes this buffer and then calls the close()
  * method on the underlying OuputStream.
  *
  */
 public function close()
 {
     if (!$this->out) {
         return;
     }
     // Remove deflating filter so we can continue writing "raw"
     stream_filter_remove($this->filter);
     // Write GZIP footer:
     // * CRC32    (CRC-32 checksum)
     // * ISIZE    (Input size)
     fwrite($this->out, pack('VV', create(new CRC32($this->md->digest()))->asInt32(), $this->length));
     fclose($this->out);
     $this->out = NULL;
 }

 /**
  * Close this buffer. Flushes this buffer and then calls the close()
  * method on the underlying OuputStream.
  *
  */
 public function close()
 {
     if (!$this->out) {
         return;
     }
     // Remove deflating filter so we can continue writing "raw"
     stream_filter_remove($this->filter);
     $final = hash_final($this->md, true);
     // Write GZIP footer:
     // * CRC32    (CRC-32 checksum)
     // * ISIZE    (Input size)
     fwrite($this->out, pack('aaaaV', $final[3], $final[2], $final[1], $final[0], $this->length));
     fclose($this->out);
     $this->out = null;
     $this->md = null;
 }

 public function getReadFilehandle()
 {
     if (!$this->final_read_fh) {
         $this->flushBuffer();
         stream_filter_remove($this->gz_filter);
         $crc = hash_final($this->file_hash, TRUE);
         // hash_final is a string, not an integer
         fwrite($this->__fh, $crc[3] . $crc[2] . $crc[1] . $crc[0]);
         // need to reverse the hash_final string so it's little endian
         fwrite($this->__fh, pack("V", $this->uncompressed_bytes), 4);
         $this->filesize = ftell($this->__fh);
         rewind($this->__fh);
         $this->final_read_fh = $this->__fh;
     }
     return $this->final_read_fh;
 }

function main()
{
    $fname = tempnam('/tmp', 'foo');
    stream_filter_register('ClosingFilter', 'ClosingFilter');
    $f = fopen($fname, 'r+');
    $filter = stream_filter_append($f, 'ClosingFilter', STREAM_FILTER_WRITE);
    fwrite($f, 'foo bar');
    fwrite($f, 'herp derp');
    var_dump('written, removing');
    stream_filter_remove($filter);
    var_dump('removed');
    fwrite($f, 'post filter');
    fclose($f);
    var_dump(file_get_contents($fname));
    unlink($fname);
}

function main()
{
    stream_filter_register('Foo', 'Foo');
    stream_filter_register('Bar', 'Bar');
    $f = fopen('php://memory', 'r+');
    $filter = stream_filter_append($f, 'Foo', STREAM_FILTER_WRITE);
    fwrite($f, 'herp');
    stream_filter_remove($filter);
    rewind($f);
    var_dump(fread($f, 1024));
    $f = fopen('php://memory', 'r+');
    $filter = stream_filter_append($f, 'Bar', STREAM_FILTER_WRITE);
    fwrite($f, 'herp');
    stream_filter_remove($filter);
    rewind($f);
    var_dump(fread($f, 1024));
}

function main()
{
    $fname = tempnam('/tmp', 'foo');
    $in = 'herpderp';
    // Build a large blob that's hard to compress
    for ($i = 0; $i < 1000; ++$i) {
        $in .= md5($in);
    }
    var_dump('input md5: ' . md5($in));
    $f = fopen($fname, 'r+');
    $filter = stream_filter_append($f, 'zlib.deflate', STREAM_FILTER_WRITE);
    foreach (str_split($in, 8096) as $chunk) {
        fwrite($f, $chunk);
    }
    stream_filter_remove($filter);
    var_dump('deflated size: ' . fstat($f)['size']);
    fclose($f);
    $contents = file_get_contents($fname);
    var_dump('deflated contents: ' . md5($contents));
    $f = fopen($fname, 'r+');
    $filter = stream_filter_append($f, 'zlib.inflate', STREAM_FILTER_WRITE);
    foreach (str_split($contents, 8096) as $chunk) {
        var_dump('chunk write: ' . strlen($chunk));
        fwrite($f, $chunk);
    }
    stream_filter_remove($filter);
    var_dump('stream size: ' . fstat($f)['size']);
    rewind($f);
    var_dump('inflated stream size: ' . fstat($f)['size']);
    var_dump('inflated stream md5: ' . md5(fread($f, fstat($f)['size'])));
    fclose($f);
    var_dump('inflated file size: ' . stat($fname)['size']);
    var_dump('inflated file md5: ' . md5(file_get_contents($fname)));
    unlink($fname);
    /* Handy for debugging - should match. Commented out as it's HHVM-only.
    
      $inflator = new __SystemLib\ChunkedInflator();
      $output = '';
      foreach (str_split($contents, 8096) as $chunk) {
        $output .= $inflator->inflateChunk($chunk);
      }
      var_dump('chunkedinflator size: '.strlen($output));
      var_dump('chunkedinflator md5: '.md5($output));
    */
}

function test_64166($data)
{
    $fd = fopen('php://temp', 'w+');
    fwrite($fd, $data);
    rewind($fd);
    $res = stream_filter_append($fd, 'convert.quoted-printable-encode', STREAM_FILTER_READ, array('line-break-chars' => "\n", 'line-length' => 74));
    $str = "";
    while (($c = fread($fd, 1)) != "") {
        $str .= $c;
    }
    var_dump($str);
    stream_filter_remove($res);
    rewind($fd);
    stream_filter_append($fd, 'convert.quoted-printable-encode', STREAM_FILTER_READ, array('line-break-chars' => "\n", 'line-length' => 6));
    $str = "";
    while (($c = fread($fd, 1)) != "") {
        $str .= $c;
    }
    var_dump($str);
    fclose($fd);
}

 /**
  * Checks if the data needs to be encoded like e.g., when outputing binary
  * data in-line during ITEMOPERATIONS requests.
  *
  * @param mixed  $data  The data to check. A string or stream resource.
  * @param string $tag   The tag we are outputing.
  *
  * @return mixed  The encoded data. A string or stream resource with
  *                a filter attached.
  */
 protected function _checkEncoding($data, $tag)
 {
     if ($tag == Horde_ActiveSync_Request_ItemOperations::ITEMOPERATIONS_DATA) {
         // See Bug: 14086. Use a STREAM_FILTER_WRITE and perform the
         // filtering here instead of using the currently broken behavior of
         // PHP when using base64-encode as STREAM_FILTER_READ. feof() is
         // apparently not safe to use when using STREAM_FILTER_READ.
         if (is_resource($data)) {
             $temp = fopen('php://temp/', 'r+');
             $filter = stream_filter_prepend($temp, 'convert.base64-encode', STREAM_FILTER_WRITE);
             rewind($data);
             while (!feof($data)) {
                 fwrite($temp, fread($data, 8192));
             }
             stream_filter_remove($filter);
             rewind($temp);
             return $temp;
         } else {
             return base64_encode($data);
         }
     }
     return $data;
 }

 public function EncodeQP($string, $line_max = 76, $space_conv = false)
 {
     if (function_exists('quoted_printable_encode')) {
         return quoted_printable_encode($string);
     }
     $filters = stream_get_filters();
     if (!in_array('convert.*', $filters)) {
         return $this->EncodeQPphp($string, $line_max, $space_conv);
     }
     $fp = fopen('php://temp/', 'r+');
     $string = preg_replace('/\\r\\n?/', $this->LE, $string);
     $params = array('line-length' => $line_max, 'line-break-chars' => $this->LE);
     $s = stream_filter_append($fp, 'convert.quoted-printable-encode', STREAM_FILTER_READ, $params);
     fputs($fp, $string);
     rewind($fp);
     $out = stream_get_contents($fp);
     stream_filter_remove($s);
     $out = preg_replace('/^\\./m', '=2E', $out);
     fclose($fp);
     return $out;
 }

 /**
  * Validate the body data to ensure consistent EOL and UTF8 data. Returns
  * body data in a stream object.
  *
  * @param array $data  The body data. @see self::_bodyPartText() for
  *                     structure.
  *
  * @return array  The validated body data array. @see self::_bodyPartText()
  */
 protected function _validateBodyData(&$data)
 {
     $stream = new Horde_Stream_Temp(array('max_memory' => 1048576));
     $filter_h = stream_filter_append($stream->stream, 'horde_eol', STREAM_FILTER_WRITE);
     $stream->add(Horde_ActiveSync_Utils::ensureUtf8($data['body'], $data['charset']), true);
     stream_filter_remove($filter_h);
     $data['body'] = $stream;
 }

 /**
  * Remove a filter
  *
  * @param string $filter   The name of the filter
  * @return  bool   Returns TRUE if the filter was detached, FALSE otherwise
  */
 public function removeFilter($filter)
 {
     $result = false;
     if (!is_resource($filter) && isset($this->_filters[$filter])) {
         $filter = $this->_filters[$filter];
     }
     if (is_resource($filter)) {
         $result = stream_filter_remove($filter);
     }
     return $result;
 }

 /**
  * if this was created with a stream, return a filtered stream for
  * reading the content. very useful for large file attachments.
  *
  * @param string $EOL
  * @return stream
  * @throws Exception\RuntimeException if not a stream or unable to append filter
  */
 public function getEncodedStream($EOL = Mime::LINEEND)
 {
     if (!$this->isStream) {
         throw new Exception\RuntimeException('Attempt to get a stream from a string part');
     }
     //stream_filter_remove(); // ??? is that right?
     switch ($this->encoding) {
         case Mime::ENCODING_QUOTEDPRINTABLE:
             if (array_key_exists(Mime::ENCODING_QUOTEDPRINTABLE, $this->filters)) {
                 stream_filter_remove($this->filters[Mime::ENCODING_QUOTEDPRINTABLE]);
             }
             $filter = stream_filter_append($this->content, 'convert.quoted-printable-encode', STREAM_FILTER_READ, array('line-length' => 76, 'line-break-chars' => $EOL));
             $this->filters[Mime::ENCODING_QUOTEDPRINTABLE] = $filter;
             if (!is_resource($filter)) {
                 throw new Exception\RuntimeException('Failed to append quoted-printable filter');
             }
             break;
         case Mime::ENCODING_BASE64:
             if (array_key_exists(Mime::ENCODING_BASE64, $this->filters)) {
                 stream_filter_remove($this->filters[Mime::ENCODING_BASE64]);
             }
             $filter = stream_filter_append($this->content, 'convert.base64-encode', STREAM_FILTER_READ, array('line-length' => 76, 'line-break-chars' => $EOL));
             $this->filters[Mime::ENCODING_BASE64] = $filter;
             if (!is_resource($filter)) {
                 throw new Exception\RuntimeException('Failed to append base64 filter');
             }
             break;
         default:
     }
     return $this->content;
 }