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 HistoryPage 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         private $mGen;
  37
  38         public function getName() {
  39                 return 'raw';
  40         }
  41
  42         public function requiresWrite() {
  43                 return false;
  44         }
  45
  46         public function requiresUnblock() {
  47                 return false;
  48         }
  49
  50         function onView() {
  51                 global $wgSquidMaxage, $wgForcedRawSMaxage;
  52
  53                 $this->getOutput()->disable();
  54                 $request = $this->getRequest();
  55
  56                 if ( !$request->checkUrlExtension() ) {
  57                         return;
  58                 }
  59
  60                 if ( $this->getOutput()->checkLastModified( $this->page->getTouched() ) ) {
  61                         return; // Client cache fresh and headers sent, nothing more to do.
  62                 }
  63
  64                 # special case for 'generated' raw things: user css/js
  65                 # This is deprecated and will only return empty content
  66                 $gen = $request->getVal( 'gen' );
  67                 $smaxage = $request->getIntOrNull( 'smaxage' );
  68
  69                 if ( $gen == 'css' || $gen == 'js' ) {
  70                         $this->mGen = $gen;
  71                         if ( $smaxage === null ) {
  72                                 $smaxage = $wgSquidMaxage;
  73                         }
  74                 } else {
  75                         $this->mGen = false;
  76                 }
  77
  78                 $contentType = $this->getContentType();
  79
  80                 # Force caching for CSS and JS raw content, default: 5 minutes.
  81                 # Note: If using a canonical url for userpage css/js, we send an HTCP purge.
  82                 if ( $smaxage === null ) {
  83                         if ( $contentType == 'text/css' || $contentType == 'text/javascript' ) {
  84                                 $smaxage = intval( $wgForcedRawSMaxage );
  85                         } else {
  86                                 $smaxage = 0;
  87                         }
  88                 }
  89
  90                 $maxage = $request->getInt( 'maxage', $wgSquidMaxage );
  91
  92                 $response = $request->response();
  93
  94                 $response->header( 'Content-type: ' . $contentType . '; charset=UTF-8' );
  95                 # Output may contain user-specific data;
  96                 # vary generated content for open sessions on private wikis
  97                 $privateCache = !User::isEveryoneAllowed( 'read' ) && ( $smaxage == 0 || session_id() != '' );
  98                 // Bug 53032 - make this private if user is logged in,
  99                 // so we don't accidentally cache cookies
 100                 $privateCache = $privateCache ?: $this->getUser()->isLoggedIn();
 101                 # allow the client to cache this for 24 hours
 102                 $mode = $privateCache ? 'private' : 'public';
 103                 $response->header(
 104                         'Cache-Control: ' . $mode . ', s-maxage=' . $smaxage . ', max-age=' . $maxage
 105                 );
 106
 107                 $text = $this->getRawText();
 108
 109                 if ( $text === false && $contentType == 'text/x-wiki' ) {
 110                         # Don't return a 404 response for CSS or JavaScript;
 111                         # 404s aren't generally cached and it would create
 112                         # extra hits when user CSS/JS are on and the user doesn't
 113                         # have the pages.
 114                         $response->header( 'HTTP/1.x 404 Not Found' );
 115                 }
 116
 117                 if ( !wfRunHooks( 'RawPageViewBeforeOutput', array( &$this, &$text ) ) ) {
 118                         wfDebug( __METHOD__ . ": RawPageViewBeforeOutput hook broke raw page output.\n" );
 119                 }
 120
 121                 echo $text;
 122         }
 123
 124         /**
 125          * Get the text that should be returned, or false if the page or revision
 126          * was not found.
 127          *
 128          * @return string|bool
 129          */
 130         public function getRawText() {
 131                 global $wgParser;
 132
 133                 # No longer used
 134                 if ( $this->mGen ) {
 135                         return '';
 136                 }
 137
 138                 $text = false;
 139                 $title = $this->getTitle();
 140                 $request = $this->getRequest();
 141
 142                 // If it's a MediaWiki message we can just hit the message cache
 143                 if ( $request->getBool( 'usemsgcache' ) && $title->getNamespace() == NS_MEDIAWIKI ) {
 144                         // The first "true" is to use the database, the second is to use
 145                         // the content langue and the last one is to specify the message
 146                         // key already contains the language in it ("/de", etc.).
 147                         $text = MessageCache::singleton()->get( $title->getDBkey(), true, true, true );
 148                         // If the message doesn't exist, return a blank
 149                         if ( $text === false ) {
 150                                 $text = '';
 151                         }
 152                 } else {
 153                         // Get it from the DB
 154                         $rev = Revision::newFromTitle( $title, $this->getOldId() );
 155                         if ( $rev ) {
 156                                 $lastmod = wfTimestamp( TS_RFC2822, $rev->getTimestamp() );
 157                                 $request->response()->header( "Last-modified: $lastmod" );
 158
 159                                 // Public-only due to cache headers
 160                                 $content = $rev->getContent();
 161
 162                                 if ( $content === null ) {
 163                                         // revision not found (or suppressed)
 164                                         $text = false;
 165                                 } elseif ( !$content instanceof TextContent ) {
 166                                         // non-text content
 167                                         wfHttpError( 415, "Unsupported Media Type", "The requested page uses the content model `"
 168                                                 . $content->getModel() . "` which is not supported via this interface." );
 169                                         die();
 170                                 } else {
 171                                         // want a section?
 172                                         $section = $request->getIntOrNull( 'section' );
 173                                         if ( $section !== null ) {
 174                                                 $content = $content->getSection( $section );
 175                                         }
 176
 177                                         if ( $content === null || $content === false ) {
 178                                                 // section not found (or section not supported, e.g. for JS and CSS)
 179                                                 $text = false;
 180                                         } else {
 181                                                 $text = $content->getNativeData();
 182                                         }
 183                                 }
 184                         }
 185                 }
 186
 187                 if ( $text !== false && $text !== '' && $request->getVal( 'templates' ) === 'expand' ) {
 188                         $text = $wgParser->preprocess(
 189                                 $text,
 190                                 $title,
 191                                 ParserOptions::newFromContext( $this->getContext() )
 192                         );
 193                 }
 194
 195                 return $text;
 196         }
 197
 198         /**
 199          * Get the ID of the revision that should used to get the text.
 200          *
 201          * @return int
 202          */
 203         public function getOldId() {
 204                 $oldid = $this->getRequest()->getInt( 'oldid' );
 205                 switch ( $this->getRequest()->getText( 'direction' ) ) {
 206                         case 'next':
 207                                 # output next revision, or nothing if there isn't one
 208                                 if ( $oldid ) {
 209                                         $oldid = $this->getTitle()->getNextRevisionID( $oldid );
 210                                 }
 211                                 $oldid = $oldid ? $oldid : -1;
 212                                 break;
 213                         case 'prev':
 214                                 # output previous revision, or nothing if there isn't one
 215                                 if ( !$oldid ) {
 216                                         # get the current revision so we can get the penultimate one
 217                                         $oldid = $this->page->getLatest();
 218                                 }
 219                                 $prev = $this->getTitle()->getPreviousRevisionID( $oldid );
 220                                 $oldid = $prev ? $prev : -1;
 221                                 break;
 222                         case 'cur':
 223                                 $oldid = 0;
 224                                 break;
 225                 }
 226
 227                 return $oldid;
 228         }
 229
 230         /**
 231          * Get the content type to use for the response
 232          *
 233          * @return string
 234          */
 235         public function getContentType() {
 236                 $ctype = $this->getRequest()->getVal( 'ctype' );
 237
 238                 if ( $ctype == '' ) {
 239                         $gen = $this->getRequest()->getVal( 'gen' );
 240                         if ( $gen == 'js' ) {
 241                                 $ctype = 'text/javascript';
 242                         } elseif ( $gen == 'css' ) {
 243                                 $ctype = 'text/css';
 244                         }
 245                 }
 246
 247                 $allowedCTypes = array( 'text/x-wiki', 'text/javascript', 'text/css', 'application/x-zope-edit' );
 248                 if ( $ctype == '' || !in_array( $ctype, $allowedCTypes ) ) {
 249                         $ctype = 'text/x-wiki';
 250                 }
 251
 252                 return $ctype;
 253         }
 254 }
 255
 256 /**
 257  * Backward compatibility for extensions
 258  *
 259  * @deprecated since 1.19
 260  */
 261 class RawPage extends RawAction {
 262         public $mOldId;
 263
 264         /**
 265          * @param Page $page
 266          * @param WebRequest|bool $request The WebRequest (default: false).
 267          */
 268         function __construct( Page $page, $request = false ) {
 269                 wfDeprecated( __CLASS__, '1.19' );
 270                 parent::__construct( $page );
 271
 272                 if ( $request !== false ) {
 273                         $context = new DerivativeContext( $this->getContext() );
 274                         $context->setRequest( $request );
 275                         $this->context = $context;
 276                 }
 277         }
 278
 279         public function view() {
 280                 $this->onView();
 281         }
 282
 283         public function getOldId() {
 284                 # Some extensions like to set $mOldId
 285                 if ( $this->mOldId !== null ) {
 286                         return $this->mOldId;
 287                 }
 288
 289                 return parent::getOldId();
 290         }
 291 }