<?php
/*
  Copyright 2005-2008 Redshift Software, Inc.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
*/
require_once(dirname(__FILE__) . '/boost.php');
require_once(dirname(__FILE__) . '/url.php');

define('BOOST_DOCS_MODIFIED_DATE', 'Sat 07 Feb 2015 21:44:00 +0000');

class BoostArchive
{
    var $params;

    function __construct($params = Array()) {
        $this->params = $params;
    }

    function get_archive_location()
    {
        $path_parts = array();
        preg_match($this->params['pattern'], $this->params['vpath'], $path_parts);

        if (in_array($path_parts[1], array('boost-build', 'regression'))) {
            $this->params['version'] = null;
            $version_dir = $path_parts[1];
        } else {
            $this->params['version'] = BoostVersion::from($path_parts[1]);
            $version_dir = is_numeric($path_parts[1][0]) ?
                "boost_{$path_parts[1]}" : $path_parts[1];
        }
        $this->params['key'] = $path_parts[2];

        $file = false;

        if ($this->params['fix_dir']) {
            $fix_path = "{$this->params['fix_dir']}/{$version_dir}/{$this->params['key']}";

            if (is_file($fix_path) ||
                (is_dir($fix_path) && is_file("{$fix_path}/index.html")))
            {
                $this->params['zipfile'] = false;
                $file = $fix_path;
            }
        }

        if (!$file) {
            $file = ($this->params['zipfile'] ? '' : $this->params['archive_dir'] . '/');

            if ($this->params['archive_subdir'])
            {
                $file = $file . $this->params['archive_file_prefix'] . $version_dir . '/' . $this->params['key'];
            }
            else
            {
                $file = $file . $this->params['archive_file_prefix'] . $this->params['key'];
            }
        }

        $this->params['file'] = $file;

        $this->params['archive'] = $this->params['zipfile'] ?
                str_replace('\\','/', $this->params['archive_dir'] . '/' . $version_dir . '.zip') :
                Null;
    }

    function display_from_archive($content_map = array())
    {
        // Set default values

        $this->params = array_merge(
            array(
                'pattern' => '@^[/]([^/]+)[/](.*)$@',
                'vpath' => $_SERVER["PATH_INFO"],
                'archive_subdir' => true,
                'zipfile' => true,
                'fix_dir' => false,
                'archive_dir' => ARCHIVE_DIR,
                'archive_file_prefix' => ARCHIVE_FILE_PREFIX,
                'use_http_expire_date' => false,
                'override_extractor' => null,
                'title' => NULL,
                'charset' => NULL,
                'content' => NULL,
                'error' => false,
            ),
            $this->params
        );

        $this->get_archive_location();

        // Only use a permanent redirect for releases (beta or full).

        $redirect_status_code = $this->params['version'] &&
            $this->params['version']->is_numbered_release() ? 301 : 302;

        // Calculate expiry date if requested.

        $expires = null;
        if ($this->params['use_http_expire_date'])
        {
            if (!$this->params['version']) {
                $expires = "+1 week";
            }
            else {
                $compare_version = BoostVersion::from($this->params['version'])->
                    compare(BoostVersion::current());
                $expires = $compare_version === -1 ? "+1 year" :
                    ($compare_version === 0 ? "+1 week" : "+1 day");
            }
        }

        // Check file exists.

        if ($this->params['zipfile'])
        {
            $check_file = $this->params['archive'];

            if (!is_readable($check_file)) {
                error_page($this->params, 'Unable to find zipfile.');
                return;
            }
        }
        else
        {
            $check_file = $this->params['file'];

            if (is_dir($check_file))
            {
                if(substr($check_file, -1) != '/') {
                    $redirect = resolve_url(basename($check_file).'/');
                    header("Location: $redirect", TRUE, $redirect_status_code);
                    return;
                }

                $found_file = NULL;
                if (is_readable("$check_file/index.html")) $found_file = 'index.html';
                else if (is_readable("$check_file/index.htm")) $found_file = 'index.htm';

                if ($found_file) {
                    $this->params['file'] = $check_file = $check_file.$found_file;
                    $this->params['key'] = $this->params['key'].$found_file;
                }
                else {
                    if (!http_headers('text/html', filemtime($check_file), $expires))
                        return;

                    $display_dir = new BoostDisplayDir($this->params);
                    return $display_dir->display($check_file);
                }
            }
            else if (!is_readable($check_file)) {
                error_page($this->params, 'Unable to find file.');
                return;
            }
        }

        // Choose filter to use

        $info_map = array_merge($content_map, array(
            array('','@[.](txt|py|rst|jam|v2|bat|sh|xml|xsl|toyxml)$@i','text','text/plain'),
            array('','@[.](qbk|quickbook)$@i','qbk','text/plain'),
            array('','@[.](c|h|cpp|hpp)$@i','cpp','text/plain'),
            array('','@[.]png$@i','raw','image/png'),
            array('','@[.]gif$@i','raw','image/gif'),
            array('','@[.](jpg|jpeg|jpe)$@i','raw','image/jpeg'),
            array('','@[.]svg$@i','raw','image/svg+xml'),
            array('','@[.]css$@i','raw','text/css'),
            array('','@[.]js$@i','raw','application/x-javascript'),
            array('','@[.]pdf$@i','raw','application/pdf'),
            array('','@[.](html|htm)$@i','raw','text/html'),
            array('','@(/|^)(Jamroot|Jamfile|ChangeLog|configure)$@i','text','text/plain'),
            array('','@[.]dtd$@i','raw','application/xml-dtd'),
            ));

        $preprocess = null;
        $extractor = null;
        $type = null;

        foreach ($info_map as $i)
        {
            if (preg_match($i[1],$this->params['key']))
            {
                if ($i[0]) {
                    $version = BoostVersion::from($i[0]);
                    if ($version->compare(BoostVersion::page()) > 0) {
                        // This is after the current version.
                        continue;
                    }
                }

                $extractor = $i[2];
                $type = $i[3];
                $preprocess = isset($i[4]) ? $i[4] : NULL;
                break;
            }
        }

        if ($this->params['override_extractor'])
            $extractor = $this->params['override_extractor'];

        if (!$extractor) {
            if (strpos($_SERVER['HTTP_HOST'], 'www.boost.org') === false) {
                error_page($this->params,
                    "No extractor found for filename.");
            } else {
                error_page($this->params);
            }
            return;
        }

        // Handle ETags and Last-Modified HTTP headers.

        // Output raw files.

        if($extractor == 'raw') {
            if (!http_headers($type, filemtime($check_file), $expires))
                return;

            display_raw_file($this->params, $_SERVER['REQUEST_METHOD'], $type);
        }
        else {
            // Read file from hard drive or zipfile

            // Note: this sets $this->params['content'] with either the
            // content or an error message.
            if(!extract_file($this->params)) {
                error_page($this->params, $this->params['content']);
                return;
            }

            // Check if the file contains a redirect.

            if($type == 'text/html') {
                if($redirect = detect_redirect($this->params['content'])) {
                    http_headers('text/html', null, "+1 day");
                    header("Location: $redirect", TRUE, $redirect_status_code);
                    if($_SERVER['REQUEST_METHOD'] != 'HEAD') echo $this->params['content'];
                    return;
                }
            }

            if (!http_headers('text/html', filemtime($check_file), $expires))
                return;

            // Finally process the file and display it.

            if($_SERVER['REQUEST_METHOD'] != 'HEAD') {
                if ($preprocess) {
                    $this->params['content'] = call_user_func($preprocess, $this->params['content']);
                }

                echo_filtered($extractor, $this->params);
            }
        }
    }
}

// HTTP header handling

function http_headers($type, $last_modified, $expires = null)
{
    header('Content-type: '.$type);
    switch($type) {
        case 'image/png':
        case 'image/gif':
        case 'image/jpeg':
        case 'text/css':
        case 'application/x-javascript':
        case 'application/pdf':
        case 'application/xml-dtd':
            header('Expires: '.date(DATE_RFC2822, strtotime("+1 year")));
            header('Cache-Control: max-age=31556926'); // A year, give or take a day.
            break;
        default:
            if($expires) {
                header('Expires: '.date(DATE_RFC2822, strtotime($expires)));
                header('Cache-Control: max-age='.strtotime($expires, 0));
            }
            break;
    }
    
    return conditional_get(max(
        strtotime(BOOST_DOCS_MODIFIED_DATE),        // last manual documenation update
        filemtime(dirname(__FILE__).'/boost.php'),  // last release (since the version number is updated)
        $last_modified                              // when the file was modified
    ));
}

function conditional_get($last_modified)
{
    if(!$last_modified) return true;

    $last_modified_text = date(DATE_RFC2822, $last_modified);
    $etag = '"'.md5($last_modified).'"';

    header("Last-Modified: $last_modified_text");
    header("ETag: $etag");

    $checked = false;

    if(isset($_SERVER['HTTP_IF_MODIFIED_SINCE'])) {
        $checked = true;
        $if_modified_since = strtotime(stripslashes($_SERVER['HTTP_IF_MODIFIED_SINCE']));
        if(!$if_modified_since || $if_modified_since < $last_modified)
            return true;
    }

    if(isset($_SERVER['HTTP_IF_NONE_MATCH'])) {
        $checked = true;
        if(stripslashes($_SERVER['HTTP_IF_NONE_MATCH'] != $etag))
            return true;
    }
    
    if(!$checked) return true;
    
    header($_SERVER["SERVER_PROTOCOL"].' 304 Not Modified');
    return false;
}

function display_raw_file($params, $method, $type)
{
    ## header('Content-Disposition: attachment; filename="downloaded.pdf"');
    if($params['zipfile']) {
        if ($method == 'HEAD') {
            $output = null;
            exec(unzip_command($params).' > /dev/null', $output, $exit_status);
        } else {
            $file_handle = popen(unzip_command($params), 'rb');
            fpassthru($file_handle);
            $exit_status = pclose($file_handle);
        }
    
        // Don't display errors for a corrupt zip file, as we seemd to
        // be getting them for legitimate files.

        if($exit_status > 1) {
            unzip_error($params, $exit_status);
            if ($params['error']) {
                header("{$_SERVER["SERVER_PROTOCOL"]} {$params['error']}", true);
            }
            echo "Error extracting file: {$params['content']}";
        }
    }
    else {
        if ($method != 'HEAD') { readfile($params['file']); }
    }
}

function extract_file(&$params) {
    if($params['zipfile']) {
        $file_handle = popen(unzip_command($params),'r');
        $text = '';
        while ($file_handle && !feof($file_handle)) {
            $text .= fread($file_handle,8*1024);
        }
        $exit_status = pclose($file_handle);

        if($exit_status == 0) {
            $params['content'] = $text;
            return true;
        }
        else {
            $params['content'] = null;
            if (strstr($_SERVER['HTTP_HOST'], 'beta')) {
                unzip_error($params, $exit_status);
            }
            return false;
        }
    }
    else {
        $params['content'] = file_get_contents($params['file']);
        return true;
    }
}

function unzip_command($params) {
    return
      UNZIP
      .' -p '.escapeshellarg($params['archive'])
      .' '.escapeshellarg($params['file']);
}

//
// Filters
//

function echo_filtered($extractor, $params) {
    $name = "BoostFilter".underscore_to_camel_case($extractor);
    $extractor = new $name($params);
    $extractor->echo_filtered();
}

function underscore_to_camel_case($name) {
    return str_replace(' ','', ucwords(str_replace('_', ' ', $name)));
}

/* File Not Found */

function error_page($params, $message = null)
{
    if (!$params['error']) { $params['error'] = "404 Not Found"; }
    header("{$_SERVER["SERVER_PROTOCOL"]} {$params['error']}");

    $head = <<<HTML
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
  <title>Boost C++ Libraries - 404 Not Found</title>
HTML;

    $content = '<h1>'.html_encode($params['error']).'</h1><p>File "' . html_encode($params['file']) . '" not found.</p><p>';
    if(!empty($params['zipfile'])) $content .= "Unzip error: ";
    $content .= html_encode($message);
    $content .= '</p>';

    $filter = new BoostFilters($params);
    $filter->display_template(Array('head' => $head, 'content' => $content));
}

/*
 * HTML processing functions
 */

function detect_redirect($content)
{
    // Only check small files, since larger files are never redirects, and are
    // expensive to search.
    if(strlen($content) <= 2000 &&
        preg_match(
            '@<meta\s+http-equiv\s*=\s*["\']?refresh["\']?\s+content\s*=\s*["\']0;\s*URL=([^"\']*)["\']\s*/?>@i',
            $content, $redirect))
    {
        return resolve_url($redirect[1]);
    }

    return false;
}

function latest_link($params)
{
    if (!isset($params['version']) || $params['error']) {
        return;
    }

    $version = BoostVersion::from($params['version']);

    $current = BoostVersion::current();
    switch ($current->compare($version))
    {
    case 0:
        break;
    case 1:
        echo '<div class="boost-common-header-notice">';
        if (realpath("{$params['archive_dir']}/{$current->dir()}/$params[key]") !== false)
        {
            echo '<a class="boost-common-header-inner" href="/doc/libs/release/',$params['key'],'">',
                "Click here to view the latest version of this page.",
                '</a>';
        }
        else
        {
            echo '<a class="boost-common-header-inner" href="/doc/libs/">',
                "This is an old version of boost. ",
                "Click here for the latest version's documentation home page.",
                '</a>';
        }
        echo '</div>', "\n";
        break;
    case -1:
        echo '<div class="boost-common-header-notice">';
        echo '<span class="boost-common-header-inner">';
        echo 'This is the documentation for a development version of boost';
        echo '</span>';
        echo '</div>', "\n";
        break;
    }
}

// Updates $params with the appropriate unzip error.

function unzip_error(&$params, $exit_status) {
    $code="500 Internal Server Error";

    switch($exit_status) {
    case 0: $message = 'No error.'; $code = null; break;
    case 1: $message = 'One  or  more  warning  errors  were  encountered.'; break;
    case 2: $message = 'A generic error in the zipfile format was detected.'; break;
    case 3: $message = 'A severe error in the zipfile format was detected.'; break;
    case 4: $message = 'Unzip was unable to allocate memory for one or more buffers during program initialization.'; break;
    case 5: $message = 'Unzip was unable to allocate memory or unable to obtain a tty to read the decryption password(s).'; break;
    case 6: $message = 'Unzip was unable to allocate memory during decompression to disk.'; break;
    case 7: $message = 'Unzip was unable to allocate memory during in-memory decompression.'; break;
    case 9:
        $message = 'The specified zipfile was not found';
        if (isset($params['archive']) && is_file($params['archive'])) {
            $message .= ' <i>(the file exists, so this is probably an error reading the file)</i>';
        }
        $message .= '.';
        break;
    case 10: $message = 'Invalid options were specified on the command line.'; break;
    case 11: $message = 'No matching files were found.'; $code="404 Not Found"; break;
    case 50: $message = 'The disk is (or was) full during extraction.'; break;
    case 51: $message = 'The end of the ZIP archive was encountered prematurely.'; break;
    case 80: $message = 'The user aborted unzip prematurely with control-C (or similar).'; break;
    case 81: $message = 'Testing or extraction of one or more files failed due to unsupported compression methods or unsupported decryption.'; break;
    case 82: $message = 'No files were found due to bad decryption password(s).'; break;
    default: $message = 'Unknown unzip error code.'; break;
    }

    $params['content'] = "Error code ".html_encode($exit_status)." - {$message}";
    if ($code) { $params['error'] = $code; }
}