Project

General

Profile

Paste
Download (34.6 KB) Statistics
| Branch: | Revision:

root / drupal7 / modules / update / update.compare.inc @ b0dc3a2e

1
<?php
2

    
3
/**
4
 * @file
5
 * Code required only when comparing available updates to existing data.
6
 */
7

    
8
/**
9
 * Fetches an array of installed and enabled projects.
10
 *
11
 * This is only responsible for generating an array of projects (taking into
12
 * account projects that include more than one module or theme). Other
13
 * information like the specific version and install type (official release,
14
 * dev snapshot, etc) is handled later in update_process_project_info() since
15
 * that logic is only required when preparing the status report, not for
16
 * fetching the available release data.
17
 *
18
 * This array is fairly expensive to construct, since it involves a lot of disk
19
 * I/O, so we cache the results into the {cache_update} table using the
20
 * 'update_project_projects' cache ID. However, since this is not the data about
21
 * available updates fetched from the network, it is acceptable to invalidate it
22
 * somewhat quickly. If we keep this data for very long, site administrators are
23
 * more likely to see incorrect results if they upgrade to a newer version of a
24
 * module or theme but do not visit certain pages that automatically clear this
25
 * cache.
26
 *
27
 * @return
28
 *   An associative array of currently enabled projects keyed by the
29
 *   machine-readable project short name. Each project contains:
30
 *   - name: The machine-readable project short name.
31
 *   - info: An array with values from the main .info file for this project.
32
 *     - name: The human-readable name of the project.
33
 *     - package: The package that the project is grouped under.
34
 *     - version: The version of the project.
35
 *     - project: The Drupal.org project name.
36
 *     - datestamp: The date stamp of the project's main .info file.
37
 *     - _info_file_ctime: The maximum file change time for all of the .info
38
 *       files included in this project.
39
 *   - datestamp: The date stamp when the project was released, if known.
40
 *   - includes: An associative array containing all projects included with this
41
 *     project, keyed by the machine-readable short name with the human-readable
42
 *     name as value.
43
 *   - project_type: The type of project. Allowed values are 'module' and
44
 *     'theme'.
45
 *   - project_status: This indicates if the project is enabled and will always
46
 *     be TRUE, as the function only returns enabled projects.
47
 *   - sub_themes: If the project is a theme it contains an associative array of
48
 *     all sub-themes.
49
 *   - base_themes: If the project is a theme it contains an associative array
50
 *     of all base-themes.
51
 *
52
 * @see update_process_project_info()
53
 * @see update_calculate_project_data()
54
 * @see update_project_cache()
55
 */
56
function update_get_projects() {
57
  $projects = &drupal_static(__FUNCTION__, array());
58
  if (empty($projects)) {
59
    // Retrieve the projects from cache, if present.
60
    $projects = update_project_cache('update_project_projects');
61
    if (empty($projects)) {
62
      // Still empty, so we have to rebuild the cache.
63
      $module_data = system_rebuild_module_data();
64
      $theme_data = system_rebuild_theme_data();
65
      _update_process_info_list($projects, $module_data, 'module', TRUE);
66
      _update_process_info_list($projects, $theme_data, 'theme', TRUE);
67
      if (variable_get('update_check_disabled', FALSE)) {
68
        _update_process_info_list($projects, $module_data, 'module', FALSE);
69
        _update_process_info_list($projects, $theme_data, 'theme', FALSE);
70
      }
71
      // Allow other modules to alter projects before fetching and comparing.
72
      drupal_alter('update_projects', $projects);
73
      // Cache the site's project data for at most 1 hour.
74
      _update_cache_set('update_project_projects', $projects, REQUEST_TIME + 3600);
75
    }
76
  }
77
  return $projects;
78
}
79

    
80
/**
81
 * Populates an array of project data.
82
 *
83
 * This iterates over a list of the installed modules or themes and groups them
84
 * by project and status. A few parts of this function assume that enabled
85
 * modules and themes are always processed first, and if disabled modules or
86
 * themes are being processed (there is a setting to control if disabled code
87
 * should be included or not in the 'Available updates' report), those are only
88
 * processed after $projects has been populated with information about the
89
 * enabled code. Modules and themes set as hidden are always ignored. This
90
 * function also records the latest change time on the .info files for each
91
 * module or theme, which is important data which is used when deciding if the
92
 * cached available update data should be invalidated.
93
 *
94
 * @param $projects
95
 *   Reference to the array of project data of what's installed on this site.
96
 * @param $list
97
 *   Array of data to process to add the relevant info to the $projects array.
98
 * @param $project_type
99
 *   The kind of data in the list. Can be 'module' or 'theme'.
100
 * @param $status
101
 *   Boolean that controls what status (enabled or disabled) to process out of
102
 *   the $list and add to the $projects array.
103
 *
104
 * @see update_get_projects()
105
 */
106
function _update_process_info_list(&$projects, $list, $project_type, $status) {
107
  $admin_theme = variable_get('admin_theme', 'seven');
108
  foreach ($list as $file) {
109
    // The admin theme is a special case. It should always be considered enabled
110
    // for the purposes of update checking.
111
    if ($file->name === $admin_theme) {
112
      $file->status = TRUE;
113
    }
114
    // A disabled base theme of an enabled sub-theme still has all of its code
115
    // run by the sub-theme, so we include it in our "enabled" projects list.
116
    if ($status && !$file->status && !empty($file->sub_themes)) {
117
      foreach ($file->sub_themes as $key => $name) {
118
        // Build a list of enabled sub-themes.
119
        if ($list[$key]->status) {
120
          $file->enabled_sub_themes[$key] = $name;
121
        }
122
      }
123
      // If there are no enabled subthemes, we should ignore this base theme
124
      // for the enabled case. If the site is trying to display disabled
125
      // themes, we'll catch it then.
126
      if (empty($file->enabled_sub_themes)) {
127
        continue;
128
      }
129
    }
130
    // Otherwise, just add projects of the proper status to our list.
131
    elseif ($file->status != $status) {
132
      continue;
133
    }
134

    
135
    // Skip if the .info file is broken.
136
    if (empty($file->info)) {
137
      continue;
138
    }
139

    
140
    // Skip if it's a hidden module or theme.
141
    if (!empty($file->info['hidden'])) {
142
      continue;
143
    }
144

    
145
    // If the .info doesn't define the 'project', try to figure it out.
146
    if (!isset($file->info['project'])) {
147
      $file->info['project'] = update_get_project_name($file);
148
    }
149

    
150
    // If we still don't know the 'project', give up.
151
    if (empty($file->info['project'])) {
152
      continue;
153
    }
154

    
155
    // If we don't already know it, grab the change time on the .info file
156
    // itself. Note: we need to use the ctime, not the mtime (modification
157
    // time) since many (all?) tar implementations will go out of their way to
158
    // set the mtime on the files it creates to the timestamps recorded in the
159
    // tarball. We want to see the last time the file was changed on disk,
160
    // which is left alone by tar and correctly set to the time the .info file
161
    // was unpacked.
162
    if (!isset($file->info['_info_file_ctime'])) {
163
      $info_filename = dirname($file->uri) . '/' . $file->name . '.info';
164
      $file->info['_info_file_ctime'] = filectime($info_filename);
165
    }
166

    
167
    if (!isset($file->info['datestamp'])) {
168
      $file->info['datestamp'] = 0;
169
    }
170

    
171
    $project_name = $file->info['project'];
172

    
173
    // Figure out what project type we're going to use to display this module
174
    // or theme. If the project name is 'drupal', we don't want it to show up
175
    // under the usual "Modules" section, we put it at a special "Drupal Core"
176
    // section at the top of the report.
177
    if ($project_name == 'drupal') {
178
      $project_display_type = 'core';
179
    }
180
    else {
181
      $project_display_type = $project_type;
182
    }
183
    if (empty($status) && empty($file->enabled_sub_themes)) {
184
      // If we're processing disabled modules or themes, append a suffix.
185
      // However, we don't do this to a a base theme with enabled
186
      // subthemes, since we treat that case as if it is enabled.
187
      $project_display_type .= '-disabled';
188
    }
189
    // Add a list of sub-themes that "depend on" the project and a list of base
190
    // themes that are "required by" the project.
191
    if ($project_name == 'drupal') {
192
      // Drupal core is always required, so this extra info would be noise.
193
      $sub_themes = array();
194
      $base_themes = array();
195
    }
196
    else {
197
      // Add list of enabled sub-themes.
198
      $sub_themes = !empty($file->enabled_sub_themes) ? $file->enabled_sub_themes : array();
199
      // Add list of base themes.
200
      $base_themes = !empty($file->base_themes) ? $file->base_themes : array();
201
    }
202
    if (!isset($projects[$project_name])) {
203
      // Only process this if we haven't done this project, since a single
204
      // project can have multiple modules or themes.
205
      $projects[$project_name] = array(
206
        'name' => $project_name,
207
        // Only save attributes from the .info file we care about so we do not
208
        // bloat our RAM usage needlessly.
209
        'info' => update_filter_project_info($file->info),
210
        'datestamp' => $file->info['datestamp'],
211
        'includes' => array($file->name => $file->info['name']),
212
        'project_type' => $project_display_type,
213
        'project_status' => $status,
214
        'sub_themes' => $sub_themes,
215
        'base_themes' => $base_themes,
216
      );
217
    }
218
    elseif ($projects[$project_name]['project_type'] == $project_display_type) {
219
      // Only add the file we're processing to the 'includes' array for this
220
      // project if it is of the same type and status (which is encoded in the
221
      // $project_display_type). This prevents listing all the disabled
222
      // modules included with an enabled project if we happen to be checking
223
      // for disabled modules, too.
224
      $projects[$project_name]['includes'][$file->name] = $file->info['name'];
225
      $projects[$project_name]['info']['_info_file_ctime'] = max($projects[$project_name]['info']['_info_file_ctime'], $file->info['_info_file_ctime']);
226
      $projects[$project_name]['datestamp'] = max($projects[$project_name]['datestamp'], $file->info['datestamp']);
227
      if (!empty($sub_themes)) {
228
        $projects[$project_name]['sub_themes'] += $sub_themes;
229
      }
230
      if (!empty($base_themes)) {
231
        $projects[$project_name]['base_themes'] += $base_themes;
232
      }
233
    }
234
    elseif (empty($status)) {
235
      // If we have a project_name that matches, but the project_display_type
236
      // does not, it means we're processing a disabled module or theme that
237
      // belongs to a project that has some enabled code. In this case, we add
238
      // the disabled thing into a separate array for separate display.
239
      $projects[$project_name]['disabled'][$file->name] = $file->info['name'];
240
    }
241
  }
242
}
243

    
244
/**
245
 * Determines what project a given file object belongs to.
246
 *
247
 * @param $file
248
 *   A file object as returned by system_get_files_database().
249
 *
250
 * @return
251
 *   The canonical project short name.
252
 *
253
 * @see system_get_files_database()
254
 */
255
function update_get_project_name($file) {
256
  $project_name = '';
257
  if (isset($file->info['project'])) {
258
    $project_name = $file->info['project'];
259
  }
260
  elseif (isset($file->info['package']) && (strpos($file->info['package'], 'Core') === 0)) {
261
    $project_name = 'drupal';
262
  }
263
  return $project_name;
264
}
265

    
266
/**
267
 * Determines version and type information for currently installed projects.
268
 *
269
 * Processes the list of projects on the system to figure out the currently
270
 * installed versions, and other information that is required before we can
271
 * compare against the available releases to produce the status report.
272
 *
273
 * @param $projects
274
 *   Array of project information from update_get_projects().
275
 */
276
function update_process_project_info(&$projects) {
277
  foreach ($projects as $key => $project) {
278
    // Assume an official release until we see otherwise.
279
    $install_type = 'official';
280

    
281
    $info = $project['info'];
282

    
283
    if (isset($info['version'])) {
284
      // Check for development snapshots
285
      if (preg_match('@(dev|HEAD)@', $info['version'])) {
286
        $install_type = 'dev';
287
      }
288

    
289
      // Figure out what the currently installed major version is. We need
290
      // to handle both contribution (e.g. "5.x-1.3", major = 1) and core
291
      // (e.g. "5.1", major = 5) version strings.
292
      $matches = array();
293
      if (preg_match('/^(\d+\.x-)?(\d+)\..*$/', $info['version'], $matches)) {
294
        $info['major'] = $matches[2];
295
      }
296
      elseif (!isset($info['major'])) {
297
        // This would only happen for version strings that don't follow the
298
        // drupal.org convention. We let contribs define "major" in their
299
        // .info in this case, and only if that's missing would we hit this.
300
        $info['major'] = -1;
301
      }
302
    }
303
    else {
304
      // No version info available at all.
305
      $install_type = 'unknown';
306
      $info['version'] = t('Unknown');
307
      $info['major'] = -1;
308
    }
309

    
310
    // Finally, save the results we care about into the $projects array.
311
    $projects[$key]['existing_version'] = $info['version'];
312
    $projects[$key]['existing_major'] = $info['major'];
313
    $projects[$key]['install_type'] = $install_type;
314
  }
315
}
316

    
317
/**
318
 * Calculates the current update status of all projects on the site.
319
 *
320
 * The results of this function are expensive to compute, especially on sites
321
 * with lots of modules or themes, since it involves a lot of comparisons and
322
 * other operations. Therefore, we cache the results into the {cache_update}
323
 * table using the 'update_project_data' cache ID. However, since this is not
324
 * the data about available updates fetched from the network, it is ok to
325
 * invalidate it somewhat quickly. If we keep this data for very long, site
326
 * administrators are more likely to see incorrect results if they upgrade to a
327
 * newer version of a module or theme but do not visit certain pages that
328
 * automatically clear this cache.
329
 *
330
 * @param array $available
331
 *   Data about available project releases.
332
 *
333
 * @return
334
 *   An array of installed projects with current update status information.
335
 *
336
 * @see update_get_available()
337
 * @see update_get_projects()
338
 * @see update_process_project_info()
339
 * @see update_project_cache()
340
 */
341
function update_calculate_project_data($available) {
342
  // Retrieve the projects from cache, if present.
343
  $projects = update_project_cache('update_project_data');
344
  // If $projects is empty, then the cache must be rebuilt.
345
  // Otherwise, return the cached data and skip the rest of the function.
346
  if (!empty($projects)) {
347
    return $projects;
348
  }
349
  $projects = update_get_projects();
350
  update_process_project_info($projects);
351
  foreach ($projects as $project => $project_info) {
352
    if (isset($available[$project])) {
353
      update_calculate_project_update_status($project, $projects[$project], $available[$project]);
354
    }
355
    else {
356
      $projects[$project]['status'] = UPDATE_UNKNOWN;
357
      $projects[$project]['reason'] = t('No available releases found');
358
    }
359
  }
360
  // Give other modules a chance to alter the status (for example, to allow a
361
  // contrib module to provide fine-grained settings to ignore specific
362
  // projects or releases).
363
  drupal_alter('update_status', $projects);
364

    
365
  // Cache the site's update status for at most 1 hour.
366
  _update_cache_set('update_project_data', $projects, REQUEST_TIME + 3600);
367
  return $projects;
368
}
369

    
370
/**
371
 * Calculates the current update status of a specific project.
372
 *
373
 * This function is the heart of the update status feature. For each project it
374
 * is invoked with, it first checks if the project has been flagged with a
375
 * special status like "unsupported" or "insecure", or if the project node
376
 * itself has been unpublished. In any of those cases, the project is marked
377
 * with an error and the next project is considered.
378
 *
379
 * If the project itself is valid, the function decides what major release
380
 * series to consider. The project defines what the currently supported major
381
 * versions are for each version of core, so the first step is to make sure the
382
 * current version is still supported. If so, that's the target version. If the
383
 * current version is unsupported, the project maintainer's recommended major
384
 * version is used. There's also a check to make sure that this function never
385
 * recommends an earlier release than the currently installed major version.
386
 *
387
 * Given a target major version, the available releases are scanned looking for
388
 * the specific release to recommend (avoiding beta releases and development
389
 * snapshots if possible). For the target major version, the highest patch level
390
 * is found. If there is a release at that patch level with no extra ("beta",
391
 * etc.), then the release at that patch level with the most recent release date
392
 * is recommended. If every release at that patch level has extra (only betas),
393
 * then the latest release from the previous patch level is recommended. For
394
 * example:
395
 *
396
 * - 1.6-bugfix <-- recommended version because 1.6 already exists.
397
 * - 1.6
398
 *
399
 * or
400
 *
401
 * - 1.6-beta
402
 * - 1.5 <-- recommended version because no 1.6 exists.
403
 * - 1.4
404
 *
405
 * Also, the latest release from the same major version is looked for, even beta
406
 * releases, to display to the user as the "Latest version" option.
407
 * Additionally, the latest official release from any higher major versions that
408
 * have been released is searched for to provide a set of "Also available"
409
 * options.
410
 *
411
 * Finally, and most importantly, the release history continues to be scanned
412
 * until the currently installed release is reached, searching for anything
413
 * marked as a security update. If any security updates have been found between
414
 * the recommended release and the installed version, all of the releases that
415
 * included a security fix are recorded so that the site administrator can be
416
 * warned their site is insecure, and links pointing to the release notes for
417
 * each security update can be included (which, in turn, will link to the
418
 * official security announcements for each vulnerability).
419
 *
420
 * This function relies on the fact that the .xml release history data comes
421
 * sorted based on major version and patch level, then finally by release date
422
 * if there are multiple releases such as betas from the same major.patch
423
 * version (e.g., 5.x-1.5-beta1, 5.x-1.5-beta2, and 5.x-1.5). Development
424
 * snapshots for a given major version are always listed last.
425
 *
426
 * @param $unused
427
 *   Input is not being used, but remains in function for API compatibility
428
 *   reasons.
429
 * @param $project_data
430
 *   An array containing information about a specific project.
431
 * @param $available
432
 *   Data about available project releases of a specific project.
433
 */
434
function update_calculate_project_update_status($unused, &$project_data, $available) {
435
  foreach (array('title', 'link') as $attribute) {
436
    if (!isset($project_data[$attribute]) && isset($available[$attribute])) {
437
      $project_data[$attribute] = $available[$attribute];
438
    }
439
  }
440

    
441
  // If the project status is marked as something bad, there's nothing else
442
  // to consider.
443
  if (isset($available['project_status'])) {
444
    switch ($available['project_status']) {
445
      case 'insecure':
446
        $project_data['status'] = UPDATE_NOT_SECURE;
447
        if (empty($project_data['extra'])) {
448
          $project_data['extra'] = array();
449
        }
450
        $project_data['extra'][] = array(
451
          'class' => array('project-not-secure'),
452
          'label' => t('Project not secure'),
453
          'data' => t('This project has been labeled insecure by the Drupal security team, and is no longer available for download. Immediately disabling everything included by this project is strongly recommended!'),
454
        );
455
        break;
456
      case 'unpublished':
457
      case 'revoked':
458
        $project_data['status'] = UPDATE_REVOKED;
459
        if (empty($project_data['extra'])) {
460
          $project_data['extra'] = array();
461
        }
462
        $project_data['extra'][] = array(
463
          'class' => array('project-revoked'),
464
          'label' => t('Project revoked'),
465
          'data' => t('This project has been revoked, and is no longer available for download. Disabling everything included by this project is strongly recommended!'),
466
        );
467
        break;
468
      case 'unsupported':
469
        $project_data['status'] = UPDATE_NOT_SUPPORTED;
470
        if (empty($project_data['extra'])) {
471
          $project_data['extra'] = array();
472
        }
473
        $project_data['extra'][] = array(
474
          'class' => array('project-not-supported'),
475
          'label' => t('Project not supported'),
476
          'data' => t('This project is no longer supported, and is no longer available for download. Disabling everything included by this project is strongly recommended!'),
477
        );
478
        break;
479
      case 'not-fetched':
480
        $project_data['status'] = UPDATE_NOT_FETCHED;
481
        $project_data['reason'] = t('Failed to get available update data.');
482
        break;
483

    
484
      default:
485
        // Assume anything else (e.g. 'published') is valid and we should
486
        // perform the rest of the logic in this function.
487
        break;
488
    }
489
  }
490

    
491
  if (!empty($project_data['status'])) {
492
    // We already know the status for this project, so there's nothing else to
493
    // compute. Record the project status into $project_data and we're done.
494
    $project_data['project_status'] = $available['project_status'];
495
    return;
496
  }
497

    
498
  // Figure out the target major version.
499
  $existing_major = $project_data['existing_major'];
500
  $supported_majors = array();
501
  if (isset($available['supported_majors'])) {
502
    $supported_majors = explode(',', $available['supported_majors']);
503
  }
504
  elseif (isset($available['default_major'])) {
505
    // Older release history XML file without supported or recommended.
506
    $supported_majors[] = $available['default_major'];
507
  }
508

    
509
  if (in_array($existing_major, $supported_majors)) {
510
    // Still supported, stay at the current major version.
511
    $target_major = $existing_major;
512
  }
513
  elseif (isset($available['recommended_major'])) {
514
    // Since 'recommended_major' is defined, we know this is the new XML
515
    // format. Therefore, we know the current release is unsupported since
516
    // its major version was not in the 'supported_majors' list. We should
517
    // find the best release from the recommended major version.
518
    $target_major = $available['recommended_major'];
519
    $project_data['status'] = UPDATE_NOT_SUPPORTED;
520
  }
521
  elseif (isset($available['default_major'])) {
522
    // Older release history XML file without recommended, so recommend
523
    // the currently defined "default_major" version.
524
    $target_major = $available['default_major'];
525
  }
526
  else {
527
    // Malformed XML file? Stick with the current version.
528
    $target_major = $existing_major;
529
  }
530

    
531
  // Make sure we never tell the admin to downgrade. If we recommended an
532
  // earlier version than the one they're running, they'd face an
533
  // impossible data migration problem, since Drupal never supports a DB
534
  // downgrade path. In the unfortunate case that what they're running is
535
  // unsupported, and there's nothing newer for them to upgrade to, we
536
  // can't print out a "Recommended version", but just have to tell them
537
  // what they have is unsupported and let them figure it out.
538
  $target_major = max($existing_major, $target_major);
539

    
540
  $release_patch_changed = '';
541
  $patch = '';
542

    
543
  // If the project is marked as UPDATE_FETCH_PENDING, it means that the
544
  // data we currently have (if any) is stale, and we've got a task queued
545
  // up to (re)fetch the data. In that case, we mark it as such, merge in
546
  // whatever data we have (e.g. project title and link), and move on.
547
  if (!empty($available['fetch_status']) && $available['fetch_status'] == UPDATE_FETCH_PENDING) {
548
    $project_data['status'] = UPDATE_FETCH_PENDING;
549
    $project_data['reason'] = t('No available update data');
550
    $project_data['fetch_status'] = $available['fetch_status'];
551
    return;
552
  }
553

    
554
  // Defend ourselves from XML history files that contain no releases.
555
  if (empty($available['releases'])) {
556
    $project_data['status'] = UPDATE_UNKNOWN;
557
    $project_data['reason'] = t('No available releases found');
558
    return;
559
  }
560
  foreach ($available['releases'] as $version => $release) {
561
    // First, if this is the existing release, check a few conditions.
562
    if ($project_data['existing_version'] === $version) {
563
      if (isset($release['terms']['Release type']) &&
564
          in_array('Insecure', $release['terms']['Release type'])) {
565
        $project_data['status'] = UPDATE_NOT_SECURE;
566
      }
567
      elseif ($release['status'] == 'unpublished') {
568
        $project_data['status'] = UPDATE_REVOKED;
569
        if (empty($project_data['extra'])) {
570
          $project_data['extra'] = array();
571
        }
572
        $project_data['extra'][] = array(
573
          'class' => array('release-revoked'),
574
          'label' => t('Release revoked'),
575
          'data' => t('Your currently installed release has been revoked, and is no longer available for download. Disabling everything included in this release or upgrading is strongly recommended!'),
576
        );
577
      }
578
      elseif (isset($release['terms']['Release type']) &&
579
              in_array('Unsupported', $release['terms']['Release type'])) {
580
        $project_data['status'] = UPDATE_NOT_SUPPORTED;
581
        if (empty($project_data['extra'])) {
582
          $project_data['extra'] = array();
583
        }
584
        $project_data['extra'][] = array(
585
          'class' => array('release-not-supported'),
586
          'label' => t('Release not supported'),
587
          'data' => t('Your currently installed release is now unsupported, and is no longer available for download. Disabling everything included in this release or upgrading is strongly recommended!'),
588
        );
589
      }
590
    }
591

    
592
    // Otherwise, ignore unpublished, insecure, or unsupported releases.
593
    if ($release['status'] == 'unpublished' ||
594
        (isset($release['terms']['Release type']) &&
595
         (in_array('Insecure', $release['terms']['Release type']) ||
596
          in_array('Unsupported', $release['terms']['Release type'])))) {
597
      continue;
598
    }
599

    
600
    // See if this is a higher major version than our target and yet still
601
    // supported. If so, record it as an "Also available" release.
602
    // Note: some projects have a HEAD release from CVS days, which could
603
    // be one of those being compared. They would not have version_major
604
    // set, so we must call isset first.
605
    if (isset($release['version_major']) && $release['version_major'] > $target_major) {
606
      if (in_array($release['version_major'], $supported_majors)) {
607
        if (!isset($project_data['also'])) {
608
          $project_data['also'] = array();
609
        }
610
        if (!isset($project_data['also'][$release['version_major']])) {
611
          $project_data['also'][$release['version_major']] = $version;
612
          $project_data['releases'][$version] = $release;
613
        }
614
      }
615
      // Otherwise, this release can't matter to us, since it's neither
616
      // from the release series we're currently using nor the recommended
617
      // release. We don't even care about security updates for this
618
      // branch, since if a project maintainer puts out a security release
619
      // at a higher major version and not at the lower major version,
620
      // they must remove the lower version from the supported major
621
      // versions at the same time, in which case we won't hit this code.
622
      continue;
623
    }
624

    
625
    // Look for the 'latest version' if we haven't found it yet. Latest is
626
    // defined as the most recent version for the target major version.
627
    if (!isset($project_data['latest_version'])
628
        && $release['version_major'] == $target_major) {
629
      $project_data['latest_version'] = $version;
630
      $project_data['releases'][$version] = $release;
631
    }
632

    
633
    // Look for the development snapshot release for this branch.
634
    if (!isset($project_data['dev_version'])
635
        && $release['version_major'] == $target_major
636
        && isset($release['version_extra'])
637
        && $release['version_extra'] == 'dev') {
638
      $project_data['dev_version'] = $version;
639
      $project_data['releases'][$version] = $release;
640
    }
641

    
642
    // Look for the 'recommended' version if we haven't found it yet (see
643
    // phpdoc at the top of this function for the definition).
644
    if (!isset($project_data['recommended'])
645
        && $release['version_major'] == $target_major
646
        && isset($release['version_patch'])) {
647
      if ($patch != $release['version_patch']) {
648
        $patch = $release['version_patch'];
649
        $release_patch_changed = $release;
650
      }
651
      if (empty($release['version_extra']) && $patch == $release['version_patch']) {
652
        $project_data['recommended'] = $release_patch_changed['version'];
653
        $project_data['releases'][$release_patch_changed['version']] = $release_patch_changed;
654
      }
655
    }
656

    
657
    // Stop searching once we hit the currently installed version.
658
    if ($project_data['existing_version'] === $version) {
659
      break;
660
    }
661

    
662
    // If we're running a dev snapshot and have a timestamp, stop
663
    // searching for security updates once we hit an official release
664
    // older than what we've got. Allow 100 seconds of leeway to handle
665
    // differences between the datestamp in the .info file and the
666
    // timestamp of the tarball itself (which are usually off by 1 or 2
667
    // seconds) so that we don't flag that as a new release.
668
    if ($project_data['install_type'] == 'dev') {
669
      if (empty($project_data['datestamp'])) {
670
        // We don't have current timestamp info, so we can't know.
671
        continue;
672
      }
673
      elseif (isset($release['date']) && ($project_data['datestamp'] + 100 > $release['date'])) {
674
        // We're newer than this, so we can skip it.
675
        continue;
676
      }
677
    }
678

    
679
    // See if this release is a security update.
680
    if (isset($release['terms']['Release type'])
681
        && in_array('Security update', $release['terms']['Release type'])) {
682
      $project_data['security updates'][] = $release;
683
    }
684
  }
685

    
686
  // If we were unable to find a recommended version, then make the latest
687
  // version the recommended version if possible.
688
  if (!isset($project_data['recommended']) && isset($project_data['latest_version'])) {
689
    $project_data['recommended'] = $project_data['latest_version'];
690
  }
691

    
692
  //
693
  // Check to see if we need an update or not.
694
  //
695

    
696
  if (!empty($project_data['security updates'])) {
697
    // If we found security updates, that always trumps any other status.
698
    $project_data['status'] = UPDATE_NOT_SECURE;
699
  }
700

    
701
  if (isset($project_data['status'])) {
702
    // If we already know the status, we're done.
703
    return;
704
  }
705

    
706
  // If we don't know what to recommend, there's nothing we can report.
707
  // Bail out early.
708
  if (!isset($project_data['recommended'])) {
709
    $project_data['status'] = UPDATE_UNKNOWN;
710
    $project_data['reason'] = t('No available releases found');
711
    return;
712
  }
713

    
714
  // If we're running a dev snapshot, compare the date of the dev snapshot
715
  // with the latest official version, and record the absolute latest in
716
  // 'latest_dev' so we can correctly decide if there's a newer release
717
  // than our current snapshot.
718
  if ($project_data['install_type'] == 'dev') {
719
    if (isset($project_data['dev_version']) && $available['releases'][$project_data['dev_version']]['date'] > $available['releases'][$project_data['latest_version']]['date']) {
720
      $project_data['latest_dev'] = $project_data['dev_version'];
721
    }
722
    else {
723
      $project_data['latest_dev'] = $project_data['latest_version'];
724
    }
725
  }
726

    
727
  // Figure out the status, based on what we've seen and the install type.
728
  switch ($project_data['install_type']) {
729
    case 'official':
730
      if ($project_data['existing_version'] === $project_data['recommended'] || $project_data['existing_version'] === $project_data['latest_version']) {
731
        $project_data['status'] = UPDATE_CURRENT;
732
      }
733
      else {
734
        $project_data['status'] = UPDATE_NOT_CURRENT;
735
      }
736
      break;
737

    
738
    case 'dev':
739
      $latest = $available['releases'][$project_data['latest_dev']];
740
      if (empty($project_data['datestamp'])) {
741
        $project_data['status'] = UPDATE_NOT_CHECKED;
742
        $project_data['reason'] = t('Unknown release date');
743
      }
744
      elseif (($project_data['datestamp'] + 100 > $latest['date'])) {
745
        $project_data['status'] = UPDATE_CURRENT;
746
      }
747
      else {
748
        $project_data['status'] = UPDATE_NOT_CURRENT;
749
      }
750
      break;
751

    
752
    default:
753
      $project_data['status'] = UPDATE_UNKNOWN;
754
      $project_data['reason'] = t('Invalid info');
755
  }
756
}
757

    
758
/**
759
 * Retrieves data from {cache_update} or empties the cache when necessary.
760
 *
761
 * Two very expensive arrays computed by this module are the list of all
762
 * installed modules and themes (and .info data, project associations, etc), and
763
 * the current status of the site relative to the currently available releases.
764
 * These two arrays are cached in the {cache_update} table and used whenever
765
 * possible. The cache is cleared whenever the administrator visits the status
766
 * report, available updates report, or the module or theme administration
767
 * pages, since we should always recompute the most current values on any of
768
 * those pages.
769
 *
770
 * Note: while both of these arrays are expensive to compute (in terms of disk
771
 * I/O and some fairly heavy CPU processing), neither of these is the actual
772
 * data about available updates that we have to fetch over the network from
773
 * updates.drupal.org. That information is stored with the
774
 * 'update_available_releases' cache ID -- it needs to persist longer than 1
775
 * hour and never get invalidated just by visiting a page on the site.
776
 *
777
 * @param $cid
778
 *   The cache ID of data to return from the cache. Valid options are
779
 *   'update_project_data' and 'update_project_projects'.
780
 *
781
 * @return
782
 *   The cached value of the $projects array generated by
783
 *   update_calculate_project_data() or update_get_projects(), or an empty array
784
 *   when the cache is cleared.
785
 */
786
function update_project_cache($cid) {
787
  $projects = array();
788

    
789
  // On certain paths, we should clear the cache and recompute the projects for
790
  // update status of the site to avoid presenting stale information.
791
  $q = $_GET['q'];
792
  $paths = array(
793
    'admin/modules',
794
    'admin/modules/update',
795
    'admin/appearance',
796
    'admin/appearance/update',
797
    'admin/reports',
798
    'admin/reports/updates',
799
    'admin/reports/updates/update',
800
    'admin/reports/status',
801
    'admin/reports/updates/check',
802
  );
803
  if (in_array($q, $paths)) {
804
    _update_cache_clear($cid);
805
  }
806
  else {
807
    $cache = _update_cache_get($cid);
808
    if (!empty($cache->data) && $cache->expire > REQUEST_TIME) {
809
      $projects = $cache->data;
810
    }
811
  }
812
  return $projects;
813
}
814

    
815
/**
816
 * Filters the project .info data to only save attributes we need.
817
 *
818
 * @param array $info
819
 *   Array of .info file data as returned by drupal_parse_info_file().
820
 *
821
 * @return
822
 *   Array of .info file data we need for the update manager.
823
 *
824
 * @see _update_process_info_list()
825
 */
826
function update_filter_project_info($info) {
827
  $whitelist = array(
828
    '_info_file_ctime',
829
    'datestamp',
830
    'major',
831
    'name',
832
    'package',
833
    'project',
834
    'project status url',
835
    'version',
836
  );
837
  return array_intersect_key($info, drupal_map_assoc($whitelist));
838
}