public function getRecommended()
 {
     static $phpOptions = array();
     if (empty($phpOptions)) {
         $phpOptions[] = array('label' => AText::_('MAIN_REC_SAFEMODE'), 'current' => (bool) ini_get('safe_mode'), 'recommended' => false);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_DISPERRORS'), 'current' => (bool) ini_get('display_errors'), 'recommended' => false);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_MCR'), 'current' => (bool) ini_get('magic_quotes_runtime'), 'recommended' => false);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_MCGPC'), 'current' => (bool) ini_get('magic_quotes_gpc'), 'recommended' => false);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_OUTBUF'), 'current' => (bool) ini_get('output_buffering'), 'recommended' => false);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_SESSIONAUTO'), 'current' => (bool) ini_get('session.auto_start'), 'recommended' => false);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_CURL'), 'current' => function_exists('curl_init'), 'recommended' => true);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_FTP'), 'current' => function_exists('ftp_connect'), 'recommended' => true);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_SSH2'), 'current' => extension_loaded('ssh2'), 'recommended' => true);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_FOPEN'), 'current' => ini_get('allow_url_fopen'), 'recommended' => true);
         if (function_exists('gzencode')) {
             $gz = @gzencode('dd') !== false;
         } else {
             $gz = false;
         }
         $phpOptions[] = array('label' => AText::_('MAIN_REC_GZ'), 'current' => $gz, 'recommended' => true);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_MCRYPT'), 'current' => function_exists('mcrypt_encrypt'), 'recommended' => true);
         $phpOptions[] = array('label' => AText::_('MAIN_REC_DOM'), 'current' => extension_loaded('Dom'), 'recommended' => true);
     }
     return $phpOptions;
 }

 function afterLayout()
 {
     if (Configure::read('Cache.disable') || Configure::read('ViewMemcache.disable')) {
         return true;
     }
     try {
         if (!empty($this->_View->viewVars['enableViewMemcache'])) {
             if (isset($this->_View->viewVars['viewMemcacheDuration'])) {
                 // CakeLog::write('debug', "ViewMemCache: duration override: {$this->_View->viewVars['viewMemcacheDuration']}");
                 @Cache::set(array('duration' => $this->_View->viewVars['viewMemcacheDuration'], null, 'view_memcache'));
                 //'+30 days' or seconds
             }
             if (!isset($this->_View->viewVars['viewMemcacheNoFooter'])) {
                 //CakeLog::write('debug', "ViewMemCache: footer disabled");
                 $this->cacheFooter = "\n<!-- ViewCached";
                 if ($this->gzipContent) {
                     $this->cacheFooter .= ' gzipped';
                 }
                 $this->cacheFooter .= ' ' . date('r') . ' -->';
             }
             if ($this->gzipContent && empty($this->_View->viewVars['viewMemcacheDisableGzip'])) {
                 //CakeLog::write('debug', "ViewMemCache: gzipping ".$this->request->here."\n\n".var_export($this->request,true)."\n\n".var_export($_SERVER,true));
                 @Cache::write($this->request->here, gzencode($this->_View->output . $this->cacheFooter, $this->compressLevel), 'view_memcache');
             } else {
                 //CakeLog::write('debug', "ViewMemCache: NOT gzipping ");
                 @Cache::write($this->request->here, $this->_View->output . $this->cacheFooter, 'view_memcache');
             }
         }
     } catch (Exception $e) {
         //do nothing
     }
     return true;
 }

 function postContent()
 {
     $this->adminGatekeeper();
     $request = $this->getInput('request');
     $key = $this->getInput('key');
     $username = $this->getInput('username');
     $json = $this->getInput('json');
     $follow_redirects = $this->getInput('follow_redirects');
     $method = $this->getInput('method', 'GET');
     $url = \Idno\Core\Idno::site()->config()->getURL();
     if (strripos($url, '/') == strlen($url) - 1) {
         $url = substr($url, 0, strlen($url) - 1);
     }
     $url .= $request;
     $client = new Webservice();
     if ($method == 'POST') {
         $result = $client->post($url, $json, array('X-KNOWN-USERNAME: ' . $username, 'X-KNOWN-SIGNATURE: ' . base64_encode(hash_hmac('sha256', $request, $key, true))));
     } else {
         $result = $client->get($url, null, array('X-KNOWN-USERNAME: ' . $username, 'X-KNOWN-SIGNATURE: ' . base64_encode(hash_hmac('sha256', $request, $key, true))));
     }
     $response = Webservice::getLastResponse();
     $sent_request = Webservice::getLastRequest() . $json;
     $api_request = array('request' => $request, 'key' => $key, 'username' => $username, 'json' => $json, 'sent_request' => $sent_request, 'response' => gzencode($response, 9), 'method' => $method);
     \Idno\Core\Idno::site()->session()->set('api_request', $api_request);
     $this->forward(\Idno\Core\Idno::site()->config()->getURL() . 'admin/apitester/');
 }

 /**
  * Put file to storage
  *
  * @param  string $file   file path in storage
  * @param  array  $params uploaded data and options
  * @return array  file size and file name
  */
 public function put($file, $params)
 {
     if (empty($params['overwrite'])) {
         $file = $this->generateName($file);
         // check if name is unique and generate new if not
     }
     $file = $this->prefix($file);
     if (!empty($params['compress'])) {
         if (!empty($params['contents'])) {
             $params['contents'] = gzencode($params['contents']);
         }
     }
     if (!fn_mkdir(dirname($file))) {
         return false;
     }
     if (!empty($params['file'])) {
         fn_copy($params['file'], $file);
     } else {
         fn_put_contents($file, $params['contents']);
     }
     if (!file_exists($file)) {
         return false;
     }
     $filesize = filesize($file);
     if (!empty($params['file']) && empty($params['keep_origins'])) {
         fn_rm($params['file']);
     }
     return array($filesize, str_replace($this->prefix(), '', $file));
 }

 public function index()
 {
     //$sitemap = new google_sitemap; //Create a new Sitemap Object
     $posts = $this->cf_blog_model->getRecentPosts('50');
     $item = $this->cf_sitemap_lib->google_sitemap_item(site_url(), date("Y-m-d", time()), 'daily', '1.0');
     //Create a new Item
     $this->cf_sitemap_lib->add_item($item);
     foreach ($posts->result_array() as $entry) {
         $link = get_page_url($entry);
         //Create a new Item
         $item = $this->cf_sitemap_lib->google_sitemap_item(site_url($link), date("Y-m-d", strtotime($entry['page_date'])), 'daily', '0.5');
         //Append the item to the sitemap object
         $this->cf_sitemap_lib->add_item($item);
     }
     $this->cf_sitemap_lib->build("sitemap.xml");
     //Build it...
     //Let's compress it to gz
     $data = implode("", file("sitemap.xml"));
     $gzdata = gzencode($data, 9);
     $fp = fopen("sitemap.xml.gz", "w");
     fwrite($fp, $gzdata);
     fclose($fp);
     //Let's Ping google
     $this->_pingGoogleSitemaps(base_url() . "/sitemap.xml.gz");
     echo site_url();
 }

 private function request($url, $data, $apiKey = null, $operation = null)
 {
     $ch = curl_init($url);
     curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->connectionTimeout);
     curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
     curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
     if ($this->certificationFile) {
         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
         curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
         curl_setopt($ch, CURLOPT_CAINFO, $this->certificationFile);
     } else {
         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
         curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
     }
     if ($this->proxy) {
         curl_setopt($ch, CURLOPT_PROXY, $this->proxy);
     }
     $headers = array("Content-Type: application/json+gzip", "User-Agent: QafooLabs Profiler Collector DevMode");
     if ($apiKey) {
         $headers[] = 'X-Profiler-Key: ' . $apiKey;
     }
     if ($operation) {
         $headers[] = 'X-Profiler-Op: ' . $operation;
     }
     curl_setopt($ch, CURLOPT_FAILONERROR, true);
     curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
     curl_setopt($ch, CURLOPT_POSTFIELDS, gzencode(json_encode($data)));
     curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
     if (curl_exec($ch) === false) {
         syslog(LOG_WARNING, "Qafoo Profiler DevMode cURL failed: " . curl_error($ch));
     }
 }

 /**
  * Compresses data and send it to the client
  *
  * @param String $data - The string to send.
  */
 public static function send($data = '')
 {
     if (!headers_sent()) {
         if (array_key_exists('HTTP_ACCEPT_ENCODING', $_SERVER)) {
             $HTTP_ACCEPT_ENCODING = $_SERVER['HTTP_ACCEPT_ENCODING'];
             if (headers_sent()) {
                 $encoding = false;
             } else {
                 if (strpos($HTTP_ACCEPT_ENCODING, 'x-gzip') !== false) {
                     $encoding = 'x-gzip';
                 } else {
                     if (strpos($HTTP_ACCEPT_ENCODING, 'gzip') !== false) {
                         $encoding = 'gzip';
                     } else {
                         $encoding = false;
                     }
                 }
             }
             // no need to waste resources in compressing very little data
             if (strlen($data) > 2048 && $encoding && function_exists('gzencode')) {
                 $data = gzencode($data, 5);
                 header('Content-Encoding: ' . $encoding);
             }
         }
         header('Content-Length: ' . strlen($data));
     }
     echo $data;
 }

 /**
  * Import products
  */
 public function actionImport()
 {
     $importer = new CsvImporter();
     $importer->deleteDownloadedImages = Yii::app()->request->getPost('remove_images');
     if (Yii::app()->request->isPostRequest && isset($_FILES['file'])) {
         $importer->file = $_FILES['file']['tmp_name'];
         if ($importer->validate() && !$importer->hasErrors()) {
             // Create db backup
             if (isset($_POST['create_dump']) && $_POST['create_dump']) {
                 Yii::import('application.components.SDatabaseDumper');
                 $dumper = new SDatabaseDumper();
                 $file = Yii::getPathOfAlias('webroot.protected.backups') . DIRECTORY_SEPARATOR . 'dump_' . date('Y-m-d_H_i_s') . '.sql';
                 if (is_writable(Yii::getPathOfAlias('webroot.protected.backups'))) {
                     if (function_exists('gzencode')) {
                         file_put_contents($file . '.gz', gzencode($dumper->getDump()));
                     } else {
                         file_put_contents($file, $dumper->getDump());
                     }
                 } else {
                     throw new CHttpException(503, Yii::t('CsvModule.admin', 'Ошибка. Директория для бэкапов недоступна для записи.'));
                 }
             }
             $importer->import();
         }
     }
     $this->render('import', array('importer' => $importer));
 }

function template_outputfilter_gzip($tpl_source, &$template_object)
{
    static $_tpl_saved = '';
    $gzipped = 0;
    if ($template_object->enable_gzip) {
        if (extension_loaded("zlib") && !get_cfg_var('zlib.output_compression') && !$template_object->cache && (strstr($_SERVER["HTTP_ACCEPT_ENCODING"], "gzip") || $template_object->force_compression)) {
            $_tpl_saved .= $tpl_source . "\n<!-- zlib compression level " . $template_object->compression_level . " -->\n\n";
            $tpl_source = "";
            if ($template_object->send_now == 1) {
                $gzipped = 1;
                $tpl_source = gzencode($_tpl_saved, $template_object->compression_level);
                $_tpl_saved = "";
            }
        }
    } else {
        if (!$template_object->caching && !get_cfg_var('zlib.output_compression')) {
            $_tpl_saved .= $tpl_source . "\n<!-- normal saved output -->\n\n";
            $tpl_source = "";
            if ($template_object->send_now == 1) {
                $tpl_source = $_tpl_saved;
                $_tpl_saved = "";
            }
        }
    }
    if ($template_object->send_now == 1 && $template_object->enable_gzip == 1) {
        if ($gzipped == 1) {
            header("Content-Encoding: gzip");
            header("Content-Length: " . strlen($tpl_source));
        }
    }
    return $tpl_source;
}

 private function setEncodingToUse($encodingUsed)
 {
     switch ($encodingUsed) {
         case 'identity':
             $this->compressFunction = function ($data) {
                 return $data;
             };
             $this->outputResponse->removeHeader('Content-Encoding');
             break;
         case 'x-gzip':
         case 'gzip':
             $this->compressFunction = function ($data) {
                 return gzencode($data);
             };
             $this->outputResponse->setHeader('Content-Encoding', 'gzip');
             break;
         case 'deflate':
             $this->compressFunction = function ($data) {
                 return zlib_encode($data, 15);
             };
             $this->outputResponse->setHeader('Content-Encoding', 'deflate');
             break;
         case 'bzip2':
             $this->compressFunction = function ($data) {
                 return bzcompress($data);
             };
             $this->outputResponse->setHeader('Content-Encoding', 'bzip2');
             break;
         default:
             throw new \LogicException('Unknown encoding');
     }
 }

 /**
  * Saves data in the cache.
  *
  * @param string $entryIdentifier An identifier for this specific cache entry
  * @param string $data The data to be stored
  * @param array $tags Tags to associate with this cache entry. If the backend does not support tags, this option can be ignored.
  * @param integer $lifetime Lifetime of this cache entry in seconds. If NULL is specified, the default lifetime is used. "0" means unlimited lifetime.
  *
  * @return void
  * @throws \TYPO3\CMS\Core\Cache\Exception if no cache frontend has been set.
  * @throws \TYPO3\CMS\Core\Cache\Exception\InvalidDataException if the data is not a string
  */
 public function set($entryIdentifier, $data, array $tags = [], $lifetime = null)
 {
     $databaseData = ['created' => $GLOBALS['EXEC_TIME'], 'expires' => $GLOBALS['EXEC_TIME'] + $this->getRealLifetime($lifetime)];
     if (in_array('explanation', $tags)) {
         $databaseData['explanation'] = $data;
         parent::set($entryIdentifier, serialize($databaseData), $tags, $lifetime);
         return;
     }
     // call set in front of the generation, because the set method
     // of the DB backend also call remove
     parent::set($entryIdentifier, serialize($databaseData), $tags, $lifetime);
     $fileName = $this->getCacheFilename($entryIdentifier);
     $cacheDir = PathUtility::pathinfo($fileName, PATHINFO_DIRNAME);
     if (!is_dir($cacheDir)) {
         GeneralUtility::mkdir_deep($cacheDir);
     }
     // normal
     GeneralUtility::writeFile($fileName, $data);
     // gz
     if ($this->configuration->get('enableStaticFileCompression')) {
         $contentGzip = gzencode($data, $this->getCompressionLevel());
         if ($contentGzip) {
             GeneralUtility::writeFile($fileName . '.gz', $contentGzip);
         }
     }
     // htaccess
     $this->writeHtAccessFile($fileName, $lifetime);
 }

 public function create($paths, $filename = FALSE)
 {
     $archive = new Archive('tar');
     foreach ($paths as $set) {
         $archive->add($set[0], $set[1]);
     }
     $gzfile = gzencode($archive->create());
     if ($filename == FALSE) {
         return $gzfile;
     }
     if (substr($filename, -7) !== '.tar.gz') {
         // Append tar extension
         $filename .= '.tar.gz';
     }
     // Create the file in binary write mode
     $file = fopen($filename, 'wb');
     // Lock the file
     flock($file, LOCK_EX);
     // Write the tar file
     $return = fwrite($file, $gzfile);
     // Unlock the file
     flock($file, LOCK_UN);
     // Close the file
     fclose($file);
     return (bool) $return;
 }

function write_to_file($filename, $stream_id, $content)
{
    global $GLOBAL_CRON;
    $file_ext = substr($filename, strrpos($filename, '.') + 1);
    switch ($file_ext) {
        case 'gz':
            $string = gzencode($content, 9);
            break;
        case 'bz2':
            $string = bzcompress($content, 9);
            break;
        default:
            $string = $content;
            break;
    }
    flush();
    if (!$GLOBAL_CRON) {
        echo $string;
    } else {
        echo "file " . $filename . " " . strlen($string) . "\n";
    }
    if ($stream_id) {
        return fwrite($stream_id, $string);
    }
}

function cssTemplate($cssFileName)
{
    global $developmode;
    $fName = substr($cssFileName, 0, strlen($cssFileName) - 4);
    $file = "cache/css/" . $fName . ".gcss";
    $dir = dirname($file);
    $cssfile = "css/{$fName}.css";
    if (!file_exists($dir)) {
        mkdir($dir, 0777, true);
    }
    if (!file_exists($file) || $developmode) {
        $fp = fopen($cssfile, 'r');
        $fz = filesize($cssfile);
        if ($fz) {
            $theData = fread($fp, $fz);
            $patterns = array("/\\/\\*[^*]*?\\*\\//", "/\n/", "/    /");
            $replacements = array("", "", "");
            $theData = preg_replace($patterns, $replacements, $theData);
        } else {
            $theData = "";
        }
        fclose($fp);
        writeToFile($file, gzencode($theData, 9));
        chmod($file, 0777);
    }
    echo "<link href=\"include/component/css.php?f={$fName}\" rel=\"stylesheet\" type=\"text/css\"/>";
}

 protected function _generateContent($code)
 {
     $url = $this->getVersionUrl();
     $type = $this->has('type') ? $this->get('type') : 'echo';
     if ($this->has('gzip_static_dir')) {
         $zlevel = $this->has('gzip_level') ? $this->get('gzip_level') : 3;
         $file_source = lmbFs::normalizePath($this->get('gzip_static_dir'), lmbFs::UNIX) . '/' . str_replace('/', '-', lmbFs::normalizePath($this->getFileUrl(), lmbFs::UNIX));
         lmbFs::cp($this->getFilePath(), $this->getRootDir() . '/' . $file_source);
         $file_gz = $file_source . '.gz';
         lmbFs::safeWrite($this->getRootDir() . '/' . $file_gz, gzencode(file_get_contents($this->getFilePath()), $zlevel, FORCE_DEFLATE));
         $url = $this->addVersion($file_source);
     }
     switch ($type) {
         case 'echo':
             if ($this->has('to_var')) {
                 $code->writePhp($this->get('to_var') . ' = \'' . addslashes($url) . '\';');
             } else {
                 $code->writeHTML(htmlspecialchars($url, 3));
             }
             break;
         case 'js':
             $code->writeHTML('<script type="text/javascript" src="' . htmlspecialchars($url, 3) . '" ></script>');
             break;
         case 'css':
             $code->writeHTML('<link rel="stylesheet" type="text/css" href="' . htmlspecialchars($url, 3) . '" />');
             break;
         default:
             throw new lmbMacroException('Unknown type ' . $type);
     }
 }

function steEncode($encodeType, $decodedString)
{
    switch (strtolower($encodeType)) {
        case 'base64':
            return base64_encode($decodedString);
        case 'gz':
            return gzencode($decodedString);
        case 'rawurl':
            return rawurlencode($decodedString);
        case 'url':
            return urlencode($decodedString);
        case 'utf8':
            return utf8_encode($decodedString);
        case 'html':
            return htmlentities($decodedString);
        case 'htmlnl':
            return nl2br(htmlentities($decodedString));
        case 'nl':
            return nl2br($decodedString);
        case 'email':
            return str_replace("@", " AT ", str_replace(".", " DOT ", str_replace("_", " UNDERLINE ", str_replace("-", " MINUS ", $decodedString))));
        default:
            return "Encoding does not support type {$encodeType}<br>";
    }
}

 public function testInflatesStreams()
 {
     $content = gzencode('test');
     $a = Psr7\stream_for($content);
     $b = new InflateStream($a);
     $this->assertEquals('test', (string) $b);
 }

 /**
  * Creates a Services_Gnip_Payload object.
  * 
  * @param string $raw required string representation of the dataset
  * @param string $title optional
  * @param string $body optional
  * @param array  $mediaURL with optional atrributes. 2d array can be sent. optional
  * optional attributes for mediaURL are:
  * height
  * width
  * duration
  * mimeType
  * type
  */
 public function __construct($raw, $title = null, $body = null, $mediaURL = null)
 {
     $this->title = $title != null ? trim($title) : null;
     $this->body = $body != null ? trim($body) : null;
     $this->mediaURL = is_array($mediaURL) ? $mediaURL : null;
     $this->raw = base64_encode(gzencode($raw));
 }

function smarty_outputfilter_gzip($tpl_source, &$smarty)
{
    /*~ the compression level to use
    		default: 9
    		-------------------------------------
    		0		->	9
    		less compressed ->	better compressed
    		less CPU usage	->	more CPU usage
    		-------------------------------------
    	*/
    $compression_level = defined('GZIP') && GZIP ? 9 : 0;
    /*~ force compression, even if gzip is not sent in HTTP_ACCEPT_ENCODING,
    		for example Norton Internet Security filters this, but 95% percent of
    		the browsers do support output compression, including Phoenix and Opera.
    		default: yes
    	*/
    $force_compession = true;
    //~ message to append to the template source, if it is compressed
    $append_message = "\n<!-- zlib compression level " . $compression_level . " -->";
    if ($compression_level && !headers_sent() && extension_loaded("zlib") && !$smarty->caching && !$smarty->debugging && (strstr($_SERVER["HTTP_ACCEPT_ENCODING"], "gzip") || $force_compession)) {
        //~ correct encoding is sent, or compression is forced
        $tpl_source = gzencode($tpl_source . $append_message, $compression_level);
        header("Content-Encoding: gzip");
        header("Vary: Accept-Encoding");
        header("Content-Length: " . strlen($tpl_source));
    }
    return $tpl_source;
}

 /**
  * @param $url
  * @param $data
  * @param $gzip
  * @param $action
  * @return mixed
  */
 private static function httpPost($url, $data, $gzip, $action)
 {
     $curl = curl_init($url);
     curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
     curl_setopt($curl, CURLOPT_BINARYTRANSFER, 1);
     curl_setopt($curl, CURLOPT_USERAGENT, 'GeTui PHP/1.0');
     curl_setopt($curl, CURLOPT_POST, 1);
     curl_setopt($curl, CURLOPT_CONNECTTIMEOUT_MS, GTConfig::getHttpConnectionTimeOut());
     curl_setopt($curl, CURLOPT_TIMEOUT_MS, GTConfig::getHttpSoTimeOut());
     $header = array('Content-Type:text/html;charset=UTF-8');
     if ($gzip) {
         $data = gzencode($data, 9);
         $header[] = 'Accept-Encoding:gzip';
         $header[] = 'Content-Encoding:gzip';
         curl_setopt($curl, CURLOPT_ENCODING, 'gzip');
     }
     if (null !== $action) {
         $header[] = 'Gt-Action:' . $action;
     }
     curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
     curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
     $curl_version = curl_version();
     if ($curl_version['version_number'] >= 462850) {
         curl_setopt($curl, CURLOPT_CONNECTTIMEOUT_MS, 30000);
         curl_setopt($curl, CURLOPT_NOSIGNAL, 1);
     }
     //通过代理访问接口需要在此处配置代理
     //curl_setopt($curl, CURLOPT_PROXY, '192.168.1.18:808');
     //请求失败有3次重试机会
     $result = HttpManager::exeBySetTimes(3, $curl);
     curl_close($curl);
     return $result;
 }