getConfig('setup.password')) {
/* May be invalid if a multisite install lost its config.php; galleryBaseUrl unknown */
header('Location: install/');
return;
}
if (GalleryUtilities::isEmbedded()) {
require_once(dirname(__FILE__) . '/init.inc');
} else {
/* If this is a request for a public data file, give it to the user immediately */
list ($view, $itemId) = GalleryUtilities::getRequestVariables('view', 'itemId');
if ($view == 'core.DownloadItem' && !empty($itemId)) {
/*
* Our urls are immutable because they have the serial numbers embedded.
* So if the browser presents us with an If-Modified-Since then it has
* the latest version of the file already.
*/
if (function_exists('getallheaders')) {
$headers = GetAllHeaders();
if (isset($headers['If-Modified-Since']) || isset($headers['If-modified-since'])) {
header('HTTP/1.x 304 Not Modified');
return;
}
}
/*
* Fast download depends on having data.gallery.cache set, so set it now. If for some
* reason we fail, we'll reset it in init.inc (but that's ok).
*/
$gallery->setConfig(
'data.gallery.cache', $gallery->getConfig('data.gallery.base') . '/cache/');
$path = GalleryDataCache::getCachePath(
array('type' => 'fast-download', 'itemId' => $itemId));
/* We don't have a platform yet so we have to use the raw file_exists */
if (file_exists($path)) {
include($path);
if (GalleryFastDownload()) {
return;
}
}
}
/* Otherwise, proceed with our regular process */
require_once(dirname(__FILE__) . '/init.inc');
$ret = GalleryInitFirstPass();
if ($ret->isError()) {
_GalleryMain_errorHandler($ret->wrap(__FILE__, __LINE__), null, false);
return;
}
/* Process the request */
GalleryMain();
}
function GalleryMain($embedded=false) {
global $gallery;
/* Process the request */
list($ret, $g2Data) = _GalleryMain($embedded);
if ($ret->isSuccess()) {
$gallery->performShutdownActions();
/* Write out our session data */
$session =& $gallery->getSession();
$ret = $session->save();
}
/* Complete our transaction */
if ($ret->isSuccess() && $gallery->isStorageInitialized()) {
$storage =& $gallery->getStorage();
$ret = $storage->commitTransaction();
}
/* Error handling (or redirect info in debug mode) */
if ($ret->isError()) {
_GalleryMain_errorHandler($ret->wrap(__FILE__, __LINE__), $g2Data);
$g2Data['isDone'] = true;
if ($ret->isError() && $gallery->isStorageInitialized()) {
/* Nuke our transaction, too */
$storage =& $gallery->getStorage();
$storage->rollbackTransaction();
}
} else if (isset($g2Data['redirectUrl'])) {
/* If we're in debug mode, show a redirect page */
print ' Debug Redirect
' .
'Not automatically redirecting you to the next page because we\'re in debug mode
';
printf('Continue to the next page', $g2Data['redirectUrl']);
print '
';
print $gallery->getDebugBuffer();
}
return $g2Data;
}
/**
* Process our request
* @return array object GalleryStatus a status code
* array[]
*/
function _GalleryMain($embedded=false) {
global $gallery;
$main = array();
$urlGenerator =& $gallery->getUrlGenerator();
$urlGenerator->initNavigation();
/* Figure out the target view/controller */
list($viewName, $controllerName) = GalleryUtilities::getRequestVariables('view', 'controller');
if (!$embedded && $gallery->getConfig('mode.embed.only') &&
$viewName != 'core.DownloadItem' && $viewName != 'imageframe.CSS') {
/* Lock out direct access when embed-only is set */
return array(GalleryStatus::error(ERROR_PERMISSION_DENIED, __FILE__, __LINE__), null);
}
/* Check if core module needs upgrading */
list ($ret, $core) = GalleryCoreApi::loadPlugin('module', 'core', true);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
$installedVersions = $core->getInstalledVersions();
if ($installedVersions['core'] != $core->getVersion()) {
$redirectUrl = $urlGenerator->getCurrentUrlDir(true) . 'upgrade/index.php';
return array(GalleryStatus::success(), _GalleryMain_doRedirect($redirectUrl));
}
$ret = GalleryInitSecondPass();
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
/* Load and run the appropriate controller */
$results = array();
if (!empty($controllerName)) {
GalleryCoreApi::relativeRequireOnce('modules/core/classes/GalleryController.class');
list ($ret, $controller) = GalleryController::loadController($controllerName);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
/* Get our form and return variables */
$form = GalleryUtilities::getFormVariables('form');
/* Let the controller handle the input */
list ($ret, $results) = $controller->handleRequest($form);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
/* Check to make sure we got back everything we want */
if (!isset($results['status']) ||
!isset($results['error']) ||
(!isset($results['redirect']) &&
!isset($results['delegate']) &&
!isset($results['return']))) {
return array(GalleryStatus::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__,
'Controller results are missing status, ' .
'error, (redirect, delegate, return)'),
null);
}
/* Try to return if the controller instructs it */
if (!empty($results['return'])) {
list ($ret, $navigationLinks) = $urlGenerator->getNavigationLinks(1);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
if (count($navigationLinks) > 0) {
/* Go back to the previous navigation point in our history */
$redirectUrl = $navigationLinks[0]['url'];
} else {
$redirectUrl = GalleryUtilities::getRequestVariables('return');
if (empty($redirectUrl)) {
$redirectUrl = GalleryUtilities::getRequestVariables('formUrl');
}
}
}
/* Failing that, redirect if so instructed */
if (empty($redirectUrl) && !empty($results['redirect'])) {
/*
* If we have a status, store its data in the session and attach it
* to the URL.
*/
if (!empty($results['status'])) {
$session =& $gallery->getSession();
$results['redirect']['statusId'] = $session->putStatus($results['status']);
}
$urlToGenerate = $results['redirect'];
/* Keep our navId in the URL */
$navId = $urlGenerator->getNavigationId();
if (!empty($navId)) {
$urlToGenerate['navId'] = $navId;
}
$redirectUrl = $urlGenerator->generateUrl($urlToGenerate);
}
/* If we have a redirect url.. use it */
if (!empty($redirectUrl)) {
return array(GalleryStatus::success(),
_GalleryMain_doRedirect($redirectUrl, null, $controllerName));
}
/* Let the controller specify the next view */
if (!empty($results['delegate'])) {
/* Load any errors into the request */
if (!empty($results['error'])) {
foreach ($results['error'] as $error) {
GalleryUtilities::putRequestVariable($error, 1);
}
}
/* Save the view name, put the rest into the request so the view can get it */
foreach ($results['delegate'] as $key => $value) {
switch($key) {
case 'view':
$viewName = $value;
break;
default:
GalleryUtilities::putRequestVariable($key, $value);
break;
}
}
}
}
/* Load and run the appropriate view */
if (empty($viewName)) {
$viewName = 'core.ShowItem';
}
list ($ret, $view) = GalleryView::loadView($viewName);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
/* Initialize our container for template data */
$gallery->setCurrentView($viewName);
/*
* If this is an immediate view, it will send its own output directly. This is
* used in the situation where we want to send back data that's not controlled by the
* layout. That's usually something that's not user-visible like a binary file.
*/
$data = array();
if ($view->isImmediate()) {
$status = isset($results['status']) ? $results['status'] : array();
$error = isset($results['error']) ? $results['error'] : array();
$ret = $view->renderImmediate($status, $error);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
$data['isDone'] = true;
} else {
GalleryCoreApi::relativeRequireOnce('modules/core/classes/GalleryTemplate.class');
$template = new GalleryTemplate(dirname(__FILE__));
list ($ret, $results, $theme) = $view->doLoadTemplate($template, $embedded);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
if (isset($results['redirect']) || isset($results['redirectUrl'])) {
if (isset($results['redirectUrl'])) {
$redirectUrl = $results['redirectUrl'];
} else {
$redirectUrl = $urlGenerator->generateUrl($results['redirect']);
}
return array(GalleryStatus::success(),
_GalleryMain_doRedirect($redirectUrl, $template));
}
if (empty($results['body'])) {
return array(GalleryStatus::error(ERROR_BAD_PARAMETER, __FILE__, __LINE__,
'View results are missing body file'), null);
}
$templatePath = 'gallery:' . $results['body'];
$template->setVariable('l10Domain', $theme->getL10Domain());
$template->setVariable('isEmbedded', $embedded);
if ($embedded) {
list ($ret, $html) = $template->fetch($templatePath);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
$data = $theme->splitHtml($html, $results);
$data['isDone'] = false;
} else {
$ret = $template->display($templatePath);
if ($ret->isError()) {
return array($ret->wrap(__FILE__, __LINE__), null);
}
$data['isDone'] = true;
}
}
return array(GalleryStatus::success(), $data);
}
function _GalleryMain_doRedirect($redirectUrl, $template=null, $controller=null) {
global $gallery;
if ($gallery->getDebug() == false || $gallery->getDebug() == 'logged') {
/*
* The URL generator makes HTML 4.01 compliant URLs using
* & but we don't want those in our Location: header.
*/
$redirectUrl = str_replace('&', '&', $redirectUrl);
/*
* IIS 3.0 - 5.0 webservers will ignore all other headers if the location header is set.
* It will simply not send other headers, e.g. the set-cookie header, which is important
* for us in the login and logout requests / redirects.
* see: http://support.microsoft.com/kb/q176113/
* Our solution: detect IIS version and append GALLERYSID to the Location URL if necessary
*/
if (in_array($controller, array('core.Logout', 'core.UserLogin', 'publishxp.Login'))) {
/* Check if it's IIS and if the version is < 6.0 */
$webserver = GalleryUtilities::getServerVar('SERVER_SOFTWARE');
if (!empty($webserver) &&
preg_match('|^Microsoft-IIS/(\d)\.\d$|', trim($webserver), $matches) &&
$matches[1] < 6) {
/*
* It is IIS and it's a version with this bug, check if GALLERYSID is already in
* the URL, else append it
*/
$session =& $gallery->getSession();
$sessionParamString =
GalleryUtilities::prefixFormVariable(urlencode($session->getKey())) . '=' .
urlencode($session->getId());
if (!strstr($redirectUrl, $sessionParamString)) {
$redirectUrl .= (strpos($redirectUrl, '?') === false) ? '?' : '&';
$redirectUrl .= $sessionParamString;
}
}
}
/* Use our PHP VM for testability */
$phpVm = $gallery->getPhpVm();
$phpVm->header("Location: $redirectUrl");
return array('isDone' => true);
} else {
return array('isDone' => true, 'redirectUrl' => $redirectUrl, 'template' => $template);
}
}
/* TODO: move this out of main.php so that we don't have load it on every page view */
function _GalleryMain_errorHandler($error, $g2Data=null, $initOk=true) {
global $gallery;
$failsafe = false;
if (!$initOk) {
$failsafe = true;
}
if (!$failsafe) {
list ($ret, $themeId) =
GalleryCoreApi::getPluginParameter('module', 'core', 'default.theme');
if ($ret->isError()) {
$failsafe = true;
}
}
if (!$failsafe) {
list ($ret, $theme) = GalleryCoreApi::loadPlugin('theme', $themeId);
if ($ret->isError()) {
$failsafe = true;
}
$templateAdapter =& $gallery->getTemplateAdapter();
$templateAdapter->setTheme($theme);
}
if (!$failsafe) {
list ($ret, $view) = GalleryView::loadView('core.ErrorPage');
if ($ret->isError()) {
$failsafe = true;
}
}
if (!$failsafe) {
$dummyForm = array();
GalleryCoreApi::relativeRequireOnce('modules/core/classes/GalleryTemplate.class');
$template = new GalleryTemplate(dirname(__FILE__));
$view->setError($error);
list ($ret, $results) = $view->loadTemplate($template, $dummyForm);
if ($ret->isError()) {
$failsafe = true;
}
$t =& $template->getVariableByReference('theme');
$t['errorTemplate'] = $results['body'];
}
if (!$failsafe) {
$template->setVariable('l10Domain', 'modules_core');
list ($ret, $templatePath) = $theme->showErrorPage($template);
if ($ret->isError()) {
$failsafe = true;
}
}
if (!$failsafe) {
$template->setVariable('l10Domain', 'themes_' . $themeId);
$ret = $template->display("themes/$themeId/templates/$templatePath");
if ($ret->isError()) {
$failsafe = true;
}
}
if ($failsafe) {
/* Some kind of catastrophic failure. Just dump the error out to the browser. */
print 'Error
' . $error->getAsHtml(false);
if ($gallery->getDebug() == 'buffered') {
print 'Debug Output
' . $gallery->getDebugBuffer() . '
';
}
return;
}
}
?>