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  * License: GPL (http://www.gnu.org/copyleft/gpl.html)
  11  *
  12  * @author Gabriel Wicke <wicke@wikidev.net>
  13  * @file
  14  */
  15
  16 /**
  17  * A simple method to retrieve the plain source of an article,
  18  * using "action=raw" in the GET request string.
  19  */
  20 class RawAction extends FormlessAction {
  21         private $mGen;
  22
  23         public function getName() {
  24                 return 'raw';
  25         }
  26
  27         public function requiresWrite() {
  28                 return false;
  29         }
  30
  31         public function requiresUnblock() {
  32                 return false;
  33         }
  34
  35         function onView() {
  36                 global $wgGroupPermissions, $wgSquidMaxage, $wgForcedRawSMaxage, $wgJsMimeType;
  37
  38                 $this->getOutput()->disable();
  39                 $request = $this->getRequest();
  40
  41                 if ( !$request->checkUrlExtension() ) {
  42                         return;
  43                 }
  44
  45                 if ( $this->getOutput()->checkLastModified( $this->page->getTouched() ) ) {
  46                         return; // Client cache fresh and headers sent, nothing more to do.
  47                 }
  48
  49                 # special case for 'generated' raw things: user css/js
  50                 # This is deprecated and will only return empty content
  51                 $gen = $request->getVal( 'gen' );
  52                 $smaxage = $request->getIntOrNull( 'smaxage' );
  53
  54                 if ( $gen == 'css' || $gen == 'js' ) {
  55                         $this->mGen = $gen;
  56                         if ( $smaxage === null ) {
  57                                 $smaxage = $wgSquidMaxage;
  58                         }
  59                 } else {
  60                         $this->mGen = false;
  61                 }
  62
  63                 $contentType = $this->getContentType();
  64
  65                 # Force caching for CSS and JS raw content, default: 5 minutes
  66                 if ( $smaxage === null ) {
  67                         if ( $contentType == 'text/css' || $contentType == $wgJsMimeType ) {
  68                                 $smaxage = intval( $wgForcedRawSMaxage );
  69                         } else {
  70                                 $smaxage = 0;
  71                         }
  72                 }
  73
  74                 $maxage = $request->getInt( 'maxage', $wgSquidMaxage );
  75
  76                 $response = $request->response();
  77
  78                 $response->header( 'Content-type: ' . $contentType . '; charset=UTF-8' );
  79                 # Output may contain user-specific data;
  80                 # vary generated content for open sessions on private wikis
  81                 $privateCache = !$wgGroupPermissions['*']['read'] && ( $smaxage == 0 || session_id() != '' );
  82                 # allow the client to cache this for 24 hours
  83                 $mode = $privateCache ? 'private' : 'public';
  84                 $response->header( 'Cache-Control: ' . $mode . ', s-maxage=' . $smaxage . ', max-age=' . $maxage );
  85
  86                 $text = $this->getRawText();
  87
  88                 if ( $text === false && $contentType == 'text/x-wiki' ) {
  89                         # Don't return a 404 response for CSS or JavaScript;
  90                         # 404s aren't generally cached and it would create
  91                         # extra hits when user CSS/JS are on and the user doesn't
  92                         # have the pages.
  93                         $response->header( 'HTTP/1.x 404 Not Found' );
  94                 }
  95
  96                 if ( !wfRunHooks( 'RawPageViewBeforeOutput', array( &$this, &$text ) ) ) {
  97                         wfDebug( __METHOD__ . ": RawPageViewBeforeOutput hook broke raw page output.\n" );
  98                 }
  99
 100                 echo $text;
 101         }
 102
 103         /**
 104          * Get the text that should be returned, or false if the page or revision
 105          * was not found.
 106          *
 107          * @return String|Bool
 108          */
 109         public function getRawText() {
 110                 global $wgParser;
 111
 112                 # No longer used
 113                 if( $this->mGen ) {
 114                         return '';
 115                 }
 116
 117                 $text = false;
 118                 $title = $this->getTitle();
 119                 $request = $this->getRequest();
 120
 121                 // If it's a MediaWiki message we can just hit the message cache
 122                 if ( $request->getBool( 'usemsgcache' ) && $title->getNamespace() == NS_MEDIAWIKI ) {
 123                         // The first "true" is to use the database, the second is to use the content langue
 124                         // and the last one is to specify the message key already contains the language in it ("/de", etc.)
 125                         $text = MessageCache::singleton()->get( $title->getDBkey(), true, true, true );
 126                         // If the message doesn't exist, return a blank
 127                         if ( $text === false ) {
 128                                 $text = '';
 129                         }
 130                 } else {
 131                         // Get it from the DB
 132                         $rev = Revision::newFromTitle( $title, $this->getOldId() );
 133                         if ( $rev ) {
 134                                 $lastmod = wfTimestamp( TS_RFC2822, $rev->getTimestamp() );
 135                                 $request->response()->header( "Last-modified: $lastmod" );
 136
 137                                 // Public-only due to cache headers
 138                                 $content = $rev->getContent();
 139
 140                                 if ( !$content instanceof TextContent ) {
 141                                         wfHttpError( 406, "Not Acceptable", "The requeste page uses the content model `"
 142                                                                                                                 . $content->getModelName() . "` which is not supported via this interface." );
 143                                         die();
 144                                 }
 145
 146                                 $section = $request->getIntOrNull( 'section' );
 147                                 if ( $section !== null ) {
 148                                         $content = $content->getSection( $section );
 149                                 }
 150
 151                                 $text = $content->getNativeData();
 152                         }
 153                 }
 154
 155                 if ( $text !== false && $text !== '' && $request->getVal( 'templates' ) === 'expand' ) {
 156                         $text = $wgParser->preprocess( $text, $title, ParserOptions::newFromContext( $this->getContext() ) );
 157                 }
 158
 159                 return $text;
 160         }
 161
 162         /**
 163          * Get the ID of the revision that should used to get the text.
 164          *
 165          * @return Integer
 166          */
 167         public function getOldId() {
 168                 $oldid = $this->getRequest()->getInt( 'oldid' );
 169                 switch ( $this->getRequest()->getText( 'direction' ) ) {
 170                         case 'next':
 171                                 # output next revision, or nothing if there isn't one
 172                                 if( $oldid ) {
 173                                         $oldid = $this->getTitle()->getNextRevisionId( $oldid );
 174                                 }
 175                                 $oldid = $oldid ? $oldid : -1;
 176                                 break;
 177                         case 'prev':
 178                                 # output previous revision, or nothing if there isn't one
 179                                 if( !$oldid ) {
 180                                         # get the current revision so we can get the penultimate one
 181                                         $oldid = $this->page->getLatest();
 182                                 }
 183                                 $prev = $this->getTitle()->getPreviousRevisionId( $oldid );
 184                                 $oldid = $prev ? $prev : -1 ;
 185                                 break;
 186                         case 'cur':
 187                                 $oldid = 0;
 188                                 break;
 189                 }
 190                 return $oldid;
 191         }
 192
 193         /**
 194          * Get the content type to use for the response
 195          *
 196          * @return String
 197          */
 198         public function getContentType() {
 199                 global $wgJsMimeType;
 200
 201                 $ctype = $this->getRequest()->getVal( 'ctype' );
 202
 203                 if ( $ctype == '' ) {
 204                         $gen = $this->getRequest()->getVal( 'gen' );
 205                         if ( $gen == 'js' ) {
 206                                 $ctype = $wgJsMimeType;
 207                         } elseif ( $gen == 'css' ) {
 208                                 $ctype = 'text/css';
 209                         }
 210                 }
 211
 212                 $allowedCTypes = array( 'text/x-wiki', $wgJsMimeType, 'text/css', 'application/x-zope-edit' );
 213                 if ( $ctype == '' || !in_array( $ctype, $allowedCTypes ) ) {
 214                         $ctype = 'text/x-wiki';
 215                 }
 216
 217                 return $ctype;
 218         }
 219 }
 220
 221 /**
 222  * Backward compatibility for extensions
 223  *
 224  * @deprecated in 1.19
 225  */
 226 class RawPage extends RawAction {
 227         public $mOldId;
 228
 229         function __construct( Page $page, $request = false ) {
 230                 wfDeprecated( __CLASS__, '1.19' );
 231                 parent::__construct( $page );
 232
 233                 if ( $request !== false ) {
 234                         $context = new DerivativeContext( $this->getContext() );
 235                         $context->setRequest( $request );
 236                         $this->context = $context;
 237                 }
 238         }
 239
 240         public function view() {
 241                 $this->onView();
 242         }
 243
 244         public function getOldId() {
 245                 # Some extensions like to set $mOldId
 246                 if ( $this->mOldId !== null ) {
 247                         return $this->mOldId;
 248                 }
 249                 return parent::getOldId();
 250         }
 251 }