This project does not seem to handle request data directly as such no vulnerable execution paths were found.
include
, or for example
via PHP's auto-loading mechanism.
These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
1 | <?php |
||
2 | /** |
||
3 | * Page existence cache. |
||
4 | * |
||
5 | * This program is free software; you can redistribute it and/or modify |
||
6 | * it under the terms of the GNU General Public License as published by |
||
7 | * the Free Software Foundation; either version 2 of the License, or |
||
8 | * (at your option) any later version. |
||
9 | * |
||
10 | * This program is distributed in the hope that it will be useful, |
||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
13 | * GNU General Public License for more details. |
||
14 | * |
||
15 | * You should have received a copy of the GNU General Public License along |
||
16 | * with this program; if not, write to the Free Software Foundation, Inc., |
||
17 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
||
18 | * http://www.gnu.org/copyleft/gpl.html |
||
19 | * |
||
20 | * @file |
||
21 | * @ingroup Cache |
||
22 | */ |
||
23 | use MediaWiki\Linker\LinkTarget; |
||
24 | use MediaWiki\MediaWikiServices; |
||
25 | |||
26 | /** |
||
27 | * Cache for article titles (prefixed DB keys) and ids linked from one source |
||
28 | * |
||
29 | * @ingroup Cache |
||
30 | */ |
||
31 | class LinkCache { |
||
32 | /** @var HashBagOStuff */ |
||
33 | private $mGoodLinks; |
||
34 | /** @var HashBagOStuff */ |
||
35 | private $mBadLinks; |
||
36 | /** @var WANObjectCache */ |
||
37 | private $wanCache; |
||
38 | |||
39 | /** @var bool */ |
||
40 | private $mForUpdate = false; |
||
41 | |||
42 | /** @var TitleFormatter */ |
||
43 | private $titleFormatter; |
||
44 | |||
45 | /** |
||
46 | * How many Titles to store. There are two caches, so the amount actually |
||
47 | * stored in memory can be up to twice this. |
||
48 | */ |
||
49 | const MAX_SIZE = 10000; |
||
50 | |||
51 | public function __construct( TitleFormatter $titleFormatter, WANObjectCache $cache ) { |
||
52 | $this->mGoodLinks = new HashBagOStuff( [ 'maxKeys' => self::MAX_SIZE ] ); |
||
53 | $this->mBadLinks = new HashBagOStuff( [ 'maxKeys' => self::MAX_SIZE ] ); |
||
54 | $this->wanCache = $cache; |
||
55 | $this->titleFormatter = $titleFormatter; |
||
56 | } |
||
57 | |||
58 | /** |
||
59 | * Get an instance of this class. |
||
60 | * |
||
61 | * @return LinkCache |
||
62 | * @deprecated since 1.28, use MediaWikiServices instead |
||
63 | */ |
||
64 | public static function singleton() { |
||
65 | return MediaWikiServices::getInstance()->getLinkCache(); |
||
66 | } |
||
67 | |||
68 | /** |
||
69 | * General accessor to get/set whether the master DB should be used |
||
70 | * |
||
71 | * This used to also set the FOR UPDATE option (locking the rows read |
||
72 | * in order to avoid link table inconsistency), which was later removed |
||
73 | * for performance on wikis with a high edit rate. |
||
74 | * |
||
75 | * @param bool $update |
||
76 | * @return bool |
||
77 | */ |
||
78 | public function forUpdate( $update = null ) { |
||
79 | return wfSetVar( $this->mForUpdate, $update ); |
||
80 | } |
||
81 | |||
82 | /** |
||
83 | * @param string $title Prefixed DB key |
||
84 | * @return int Page ID or zero |
||
85 | */ |
||
86 | public function getGoodLinkID( $title ) { |
||
87 | $info = $this->mGoodLinks->get( $title ); |
||
88 | if ( !$info ) { |
||
89 | return 0; |
||
90 | } |
||
91 | return $info['id']; |
||
92 | } |
||
93 | |||
94 | /** |
||
95 | * Get a field of a title object from cache. |
||
96 | * If this link is not a cached good title, it will return NULL. |
||
97 | * @param LinkTarget $target |
||
98 | * @param string $field ('length','redirect','revision','model') |
||
99 | * @return string|int|null |
||
100 | */ |
||
101 | public function getGoodLinkFieldObj( LinkTarget $target, $field ) { |
||
102 | $dbkey = $this->titleFormatter->getPrefixedDBkey( $target ); |
||
103 | $info = $this->mGoodLinks->get( $dbkey ); |
||
104 | if ( !$info ) { |
||
105 | return null; |
||
106 | } |
||
107 | return $info[$field]; |
||
108 | } |
||
109 | |||
110 | /** |
||
111 | * @param string $title Prefixed DB key |
||
112 | * @return bool |
||
113 | */ |
||
114 | public function isBadLink( $title ) { |
||
115 | // Use get() to ensure it records as used for LRU. |
||
116 | return $this->mBadLinks->get( $title ) !== false; |
||
117 | } |
||
118 | |||
119 | /** |
||
120 | * Add a link for the title to the link cache |
||
121 | * |
||
122 | * @param int $id Page's ID |
||
123 | * @param LinkTarget $target |
||
124 | * @param int $len Text's length |
||
125 | * @param int $redir Whether the page is a redirect |
||
126 | * @param int $revision Latest revision's ID |
||
127 | * @param string|null $model Latest revision's content model ID |
||
128 | * @param string|null $lang Language code of the page, if not the content language |
||
129 | */ |
||
130 | public function addGoodLinkObj( $id, LinkTarget $target, $len = -1, $redir = null, |
||
131 | $revision = 0, $model = null, $lang = null |
||
132 | ) { |
||
133 | $dbkey = $this->titleFormatter->getPrefixedDBkey( $target ); |
||
134 | $this->mGoodLinks->set( $dbkey, [ |
||
135 | 'id' => (int)$id, |
||
136 | 'length' => (int)$len, |
||
137 | 'redirect' => (int)$redir, |
||
138 | 'revision' => (int)$revision, |
||
139 | 'model' => $model ? (string)$model : null, |
||
140 | 'lang' => $lang ? (string)$lang : null, |
||
141 | ] ); |
||
142 | } |
||
143 | |||
144 | /** |
||
145 | * Same as above with better interface. |
||
146 | * @since 1.19 |
||
147 | * @param LinkTarget $target |
||
148 | * @param stdClass $row Object which has the fields page_id, page_is_redirect, |
||
149 | * page_latest and page_content_model |
||
150 | */ |
||
151 | public function addGoodLinkObjFromRow( LinkTarget $target, $row ) { |
||
152 | $dbkey = $this->titleFormatter->getPrefixedDBkey( $target ); |
||
153 | $this->mGoodLinks->set( $dbkey, [ |
||
154 | 'id' => intval( $row->page_id ), |
||
155 | 'length' => intval( $row->page_len ), |
||
156 | 'redirect' => intval( $row->page_is_redirect ), |
||
157 | 'revision' => intval( $row->page_latest ), |
||
158 | 'model' => !empty( $row->page_content_model ) ? strval( $row->page_content_model ) : null, |
||
159 | 'lang' => !empty( $row->page_lang ) ? strval( $row->page_lang ) : null, |
||
160 | ] ); |
||
161 | } |
||
162 | |||
163 | /** |
||
164 | * @param LinkTarget $target |
||
165 | */ |
||
166 | public function addBadLinkObj( LinkTarget $target ) { |
||
167 | $dbkey = $this->titleFormatter->getPrefixedDBkey( $target ); |
||
168 | if ( !$this->isBadLink( $dbkey ) ) { |
||
169 | $this->mBadLinks->set( $dbkey, 1 ); |
||
170 | } |
||
171 | } |
||
172 | |||
173 | /** |
||
174 | * @param string $title Prefixed DB key |
||
175 | */ |
||
176 | public function clearBadLink( $title ) { |
||
177 | $this->mBadLinks->delete( $title ); |
||
178 | } |
||
179 | |||
180 | /** |
||
181 | * @param LinkTarget $target |
||
182 | */ |
||
183 | public function clearLink( LinkTarget $target ) { |
||
184 | $dbkey = $this->titleFormatter->getPrefixedDBkey( $target ); |
||
185 | $this->mBadLinks->delete( $dbkey ); |
||
186 | $this->mGoodLinks->delete( $dbkey ); |
||
187 | } |
||
188 | |||
189 | /** |
||
190 | * Add a title to the link cache, return the page_id or zero if non-existent |
||
191 | * |
||
192 | * @deprecated since 1.27, unused |
||
193 | * @param string $title Prefixed DB key |
||
194 | * @return int Page ID or zero |
||
195 | */ |
||
196 | public function addLink( $title ) { |
||
197 | $nt = Title::newFromDBkey( $title ); |
||
198 | if ( !$nt ) { |
||
199 | return 0; |
||
200 | } |
||
201 | return $this->addLinkObj( $nt ); |
||
202 | } |
||
203 | |||
204 | /** |
||
205 | * Fields that LinkCache needs to select |
||
206 | * |
||
207 | * @since 1.28 |
||
208 | * @return array |
||
209 | */ |
||
210 | View Code Duplication | public static function getSelectFields() { |
|
211 | global $wgContentHandlerUseDB, $wgPageLanguageUseDB; |
||
212 | |||
213 | $fields = [ 'page_id', 'page_len', 'page_is_redirect', 'page_latest' ]; |
||
214 | if ( $wgContentHandlerUseDB ) { |
||
215 | $fields[] = 'page_content_model'; |
||
216 | } |
||
217 | if ( $wgPageLanguageUseDB ) { |
||
218 | $fields[] = 'page_lang'; |
||
219 | } |
||
220 | |||
221 | return $fields; |
||
222 | } |
||
223 | |||
224 | /** |
||
225 | * Add a title to the link cache, return the page_id or zero if non-existent |
||
226 | * |
||
227 | * @param LinkTarget $nt LinkTarget object to add |
||
228 | * @return int Page ID or zero |
||
229 | */ |
||
230 | public function addLinkObj( LinkTarget $nt ) { |
||
231 | $key = $this->titleFormatter->getPrefixedDBkey( $nt ); |
||
232 | if ( $this->isBadLink( $key ) || $nt->isExternal() |
||
233 | || $nt->inNamespace( NS_SPECIAL ) |
||
234 | ) { |
||
235 | return 0; |
||
236 | } |
||
237 | $id = $this->getGoodLinkID( $key ); |
||
238 | if ( $id != 0 ) { |
||
239 | return $id; |
||
240 | } |
||
241 | |||
242 | if ( $key === '' ) { |
||
243 | return 0; |
||
244 | } |
||
245 | |||
246 | // Cache template/file pages as they are less often viewed but heavily used |
||
247 | if ( $this->mForUpdate ) { |
||
248 | $row = $this->fetchPageRow( wfGetDB( DB_MASTER ), $nt ); |
||
0 ignored issues
–
show
|
|||
249 | } elseif ( $this->isCacheable( $nt ) ) { |
||
250 | // These pages are often transcluded heavily, so cache them |
||
251 | $cache = $this->wanCache; |
||
252 | $row = $cache->getWithSetCallback( |
||
253 | $cache->makeKey( 'page', $nt->getNamespace(), sha1( $nt->getDBkey() ) ), |
||
254 | $cache::TTL_DAY, |
||
255 | function ( $curValue, &$ttl, array &$setOpts ) use ( $cache, $nt ) { |
||
256 | $dbr = wfGetDB( DB_REPLICA ); |
||
257 | $setOpts += Database::getCacheSetOptions( $dbr ); |
||
258 | |||
259 | $row = $this->fetchPageRow( $dbr, $nt ); |
||
0 ignored issues
–
show
It seems like
$dbr defined by wfGetDB(DB_REPLICA) on line 256 can be null ; however, LinkCache::fetchPageRow() does not accept null , maybe add an additional type check?
Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass|null */
function mayReturnNull() { }
function doesNotAcceptNull(stdClass $x) { }
// With potential error.
function withoutCheck() {
$x = mayReturnNull();
doesNotAcceptNull($x); // Potential error here.
}
// Safe - Alternative 1
function withCheck1() {
$x = mayReturnNull();
if ( ! $x instanceof stdClass) {
throw new \LogicException('$x must be defined.');
}
doesNotAcceptNull($x);
}
// Safe - Alternative 2
function withCheck2() {
$x = mayReturnNull();
if ($x instanceof stdClass) {
doesNotAcceptNull($x);
}
}
![]() |
|||
260 | $mtime = $row ? wfTimestamp( TS_UNIX, $row->page_touched ) : false; |
||
261 | $ttl = $cache->adaptiveTTL( $mtime, $ttl ); |
||
262 | |||
263 | return $row; |
||
264 | } |
||
265 | ); |
||
266 | } else { |
||
267 | $row = $this->fetchPageRow( wfGetDB( DB_REPLICA ), $nt ); |
||
0 ignored issues
–
show
It seems like
wfGetDB(DB_REPLICA) can be null ; however, fetchPageRow() does not accept null , maybe add an additional type check?
Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass|null */
function mayReturnNull() { }
function doesNotAcceptNull(stdClass $x) { }
// With potential error.
function withoutCheck() {
$x = mayReturnNull();
doesNotAcceptNull($x); // Potential error here.
}
// Safe - Alternative 1
function withCheck1() {
$x = mayReturnNull();
if ( ! $x instanceof stdClass) {
throw new \LogicException('$x must be defined.');
}
doesNotAcceptNull($x);
}
// Safe - Alternative 2
function withCheck2() {
$x = mayReturnNull();
if ($x instanceof stdClass) {
doesNotAcceptNull($x);
}
}
![]() |
|||
268 | } |
||
269 | |||
270 | if ( $row ) { |
||
271 | $this->addGoodLinkObjFromRow( $nt, $row ); |
||
272 | $id = intval( $row->page_id ); |
||
273 | } else { |
||
274 | $this->addBadLinkObj( $nt ); |
||
275 | $id = 0; |
||
276 | } |
||
277 | |||
278 | return $id; |
||
279 | } |
||
280 | |||
281 | private function isCacheable( LinkTarget $title ) { |
||
282 | return ( $title->inNamespace( NS_TEMPLATE ) || $title->inNamespace( NS_FILE ) ); |
||
283 | } |
||
284 | |||
285 | private function fetchPageRow( IDatabase $db, LinkTarget $nt ) { |
||
286 | $fields = self::getSelectFields(); |
||
287 | if ( $this->isCacheable( $nt ) ) { |
||
288 | $fields[] = 'page_touched'; |
||
289 | } |
||
290 | |||
291 | return $db->selectRow( |
||
292 | 'page', |
||
293 | $fields, |
||
294 | [ 'page_namespace' => $nt->getNamespace(), 'page_title' => $nt->getDBkey() ], |
||
295 | __METHOD__ |
||
296 | ); |
||
297 | } |
||
298 | |||
299 | /** |
||
300 | * Purge the link cache for a title |
||
301 | * |
||
302 | * @param LinkTarget $title |
||
303 | * @since 1.28 |
||
304 | */ |
||
305 | public function invalidateTitle( LinkTarget $title ) { |
||
306 | if ( $this->isCacheable( $title ) ) { |
||
307 | $cache = ObjectCache::getMainWANInstance(); |
||
308 | $cache->delete( |
||
309 | $cache->makeKey( 'page', $title->getNamespace(), sha1( $title->getDBkey() ) ) |
||
310 | ); |
||
311 | } |
||
312 | } |
||
313 | |||
314 | /** |
||
315 | * Clears cache |
||
316 | */ |
||
317 | public function clear() { |
||
318 | $this->mGoodLinks->clear(); |
||
319 | $this->mBadLinks->clear(); |
||
320 | } |
||
321 | } |
||
322 |
Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: