includes/actions/RawAction.php

   1 <?php
   2 /**
   3  * Raw page text accessor
   4  *
   5  * Copyright © 2004 Gabriel Wicke <wicke@wikidev.net>
   6  * http://wikidev.net/
   7  *
   8  * Based on HistoryAction and SpecialExport
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  * http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * @author Gabriel Wicke <wicke@wikidev.net>
  26  * @file
  27  */
  28
  29 /**
  30  * A simple method to retrieve the plain source of an article,
  31  * using "action=raw" in the GET request string.
  32  *
  33  * @ingroup Actions
  34  */
  35 class RawAction extends FormlessAction {
  36         /**
  37          * Whether the request includes a 'gen' parameter
  38          * @var bool
  39          * @deprecated since 1.17 This used to be a string for "css" or "javascript" but
  40          * it is no longer used. Setting this parameter results in an empty response.
  41          */
  42         private $gen = false;
  43
  44         public function getName() {
  45                 return 'raw';
  46         }
  47
  48         public function requiresWrite() {
  49                 return false;
  50         }
  51
  52         public function requiresUnblock() {
  53                 return false;
  54         }
  55
  56         function onView() {
  57                 $this->getOutput()->disable();
  58                 $request = $this->getRequest();
  59                 $response = $request->response();
  60                 $config = $this->context->getConfig();
  61
  62                 if ( !$request->checkUrlExtension() ) {
  63                         return;
  64                 }
  65
  66                 if ( $this->getOutput()->checkLastModified( $this->page->getTouched() ) ) {
  67                         return; // Client cache fresh and headers sent, nothing more to do.
  68                 }
  69
  70                 $gen = $request->getVal( 'gen' );
  71                 if ( $gen == 'css' || $gen == 'js' ) {
  72                         $this->gen = true;
  73                 }
  74
  75                 $contentType = $this->getContentType();
  76
  77                 $maxage = $request->getInt( 'maxage', $config->get( 'SquidMaxage' ) );
  78                 $smaxage = $request->getIntOrNull( 'smaxage' );
  79                 if ( $smaxage === null ) {
  80                         if ( $this->gen ) {
  81                                 $smaxage = $config->get( 'SquidMaxage' );
  82                         } elseif ( $contentType == 'text/css' || $contentType == 'text/javascript' ) {
  83                                 // CSS/JS raw content has its own squid max age configuration.
  84                                 // Note: Title::getSquidURLs() includes action=raw for css/js pages,
  85                                 // so if using the canonical url, this will get HTCP purges.
  86                                 $smaxage = intval( $config->get( 'ForcedRawSMaxage' ) );
  87                         } else {
  88                                 // No squid cache for anything else
  89                                 $smaxage = 0;
  90                         }
  91                 }
  92
  93                 $response->header( 'Content-type: ' . $contentType . '; charset=UTF-8' );
  94                 // Output may contain user-specific data;
  95                 // vary generated content for open sessions on private wikis
  96                 $privateCache = !User::isEveryoneAllowed( 'read' ) && ( $smaxage == 0 || session_id() != '' );
  97                 // Don't accidentally cache cookies if user is logged in (T55032)
  98                 $privateCache = $privateCache || $this->getUser()->isLoggedIn();
  99                 $mode = $privateCache ? 'private' : 'public';
 100                 $response->header(
 101                         'Cache-Control: ' . $mode . ', s-maxage=' . $smaxage . ', max-age=' . $maxage
 102                 );
 103
 104                 $text = $this->getRawText();
 105
 106                 // Don't return a 404 response for CSS or JavaScript;
 107                 // 404s aren't generally cached and it would create
 108                 // extra hits when user CSS/JS are on and the user doesn't
 109                 // have the pages.
 110                 if ( $text === false && $contentType == 'text/x-wiki' ) {
 111                         $response->statusHeader( 404 );
 112                 }
 113
 114                 if ( !Hooks::run( 'RawPageViewBeforeOutput', array( &$this, &$text ) ) ) {
 115                         wfDebug( __METHOD__ . ": RawPageViewBeforeOutput hook broke raw page output.\n" );
 116                 }
 117
 118                 echo $text;
 119         }
 120
 121         /**
 122          * Get the text that should be returned, or false if the page or revision
 123          * was not found.
 124          *
 125          * @return string|bool
 126          */
 127         public function getRawText() {
 128                 global $wgParser;
 129
 130                 # No longer used
 131                 if ( $this->gen ) {
 132                         return '';
 133                 }
 134
 135                 $text = false;
 136                 $title = $this->getTitle();
 137                 $request = $this->getRequest();
 138
 139                 // If it's a MediaWiki message we can just hit the message cache
 140                 if ( $request->getBool( 'usemsgcache' ) && $title->getNamespace() == NS_MEDIAWIKI ) {
 141                         // The first "true" is to use the database, the second is to use
 142                         // the content langue and the last one is to specify the message
 143                         // key already contains the language in it ("/de", etc.).
 144                         $text = MessageCache::singleton()->get( $title->getDBkey(), true, true, true );
 145                         // If the message doesn't exist, return a blank
 146                         if ( $text === false ) {
 147                                 $text = '';
 148                         }
 149                 } else {
 150                         // Get it from the DB
 151                         $rev = Revision::newFromTitle( $title, $this->getOldId() );
 152                         if ( $rev ) {
 153                                 $lastmod = wfTimestamp( TS_RFC2822, $rev->getTimestamp() );
 154                                 $request->response()->header( "Last-modified: $lastmod" );
 155
 156                                 // Public-only due to cache headers
 157                                 $content = $rev->getContent();
 158
 159                                 if ( $content === null ) {
 160                                         // revision not found (or suppressed)
 161                                         $text = false;
 162                                 } elseif ( !$content instanceof TextContent ) {
 163                                         // non-text content
 164                                         wfHttpError( 415, "Unsupported Media Type", "The requested page uses the content model `"
 165                                                 . $content->getModel() . "` which is not supported via this interface." );
 166                                         die();
 167                                 } else {
 168                                         // want a section?
 169                                         $section = $request->getIntOrNull( 'section' );
 170                                         if ( $section !== null ) {
 171                                                 $content = $content->getSection( $section );
 172                                         }
 173
 174                                         if ( $content === null || $content === false ) {
 175                                                 // section not found (or section not supported, e.g. for JS and CSS)
 176                                                 $text = false;
 177                                         } else {
 178                                                 $text = $content->getNativeData();
 179                                         }
 180                                 }
 181                         }
 182                 }
 183
 184                 if ( $text !== false && $text !== '' && $request->getVal( 'templates' ) === 'expand' ) {
 185                         $text = $wgParser->preprocess(
 186                                 $text,
 187                                 $title,
 188                                 ParserOptions::newFromContext( $this->getContext() )
 189                         );
 190                 }
 191
 192                 return $text;
 193         }
 194
 195         /**
 196          * Get the ID of the revision that should used to get the text.
 197          *
 198          * @return int
 199          */
 200         public function getOldId() {
 201                 $oldid = $this->getRequest()->getInt( 'oldid' );
 202                 switch ( $this->getRequest()->getText( 'direction' ) ) {
 203                         case 'next':
 204                                 # output next revision, or nothing if there isn't one
 205                                 $nextid = 0;
 206                                 if ( $oldid ) {
 207                                         $nextid = $this->getTitle()->getNextRevisionID( $oldid );
 208                                 }
 209                                 $oldid = $nextid ?: -1;
 210                                 break;
 211                         case 'prev':
 212                                 # output previous revision, or nothing if there isn't one
 213                                 if ( !$oldid ) {
 214                                         # get the current revision so we can get the penultimate one
 215                                         $oldid = $this->page->getLatest();
 216                                 }
 217                                 $previd = $this->getTitle()->getPreviousRevisionID( $oldid );
 218                                 $oldid = $previd ?: -1;
 219                                 break;
 220                         case 'cur':
 221                                 $oldid = 0;
 222                                 break;
 223                 }
 224
 225                 return $oldid;
 226         }
 227
 228         /**
 229          * Get the content type to use for the response
 230          *
 231          * @return string
 232          */
 233         public function getContentType() {
 234                 $ctype = $this->getRequest()->getVal( 'ctype' );
 235
 236                 if ( $ctype == '' ) {
 237                         $gen = $this->getRequest()->getVal( 'gen' );
 238                         if ( $gen == 'js' ) {
 239                                 $ctype = 'text/javascript';
 240                         } elseif ( $gen == 'css' ) {
 241                                 $ctype = 'text/css';
 242                         }
 243                 }
 244
 245                 $allowedCTypes = array( 'text/x-wiki', 'text/javascript', 'text/css', 'application/x-zope-edit' );
 246                 if ( $ctype == '' || !in_array( $ctype, $allowedCTypes ) ) {
 247                         $ctype = 'text/x-wiki';
 248                 }
 249
 250                 return $ctype;
 251         }
 252 }