install.inc 37.9 KB
Newer Older
1
2
<?php

3
4
5
6
7
 /**
 * @file
 * API functions for installing modules and themes.
 */

8
use Drupal\Core\Database\Database;
9
use Drupal\Core\DrupalKernel;
10
use Drupal\locale\Gettext;
11

12
13
14
/**
 * Requirement severity -- Informational message only.
 */
15
const REQUIREMENT_INFO = -1;
16
17
18
19

/**
 * Requirement severity -- Requirement successfully met.
 */
20
const REQUIREMENT_OK = 0;
21
22
23
24

/**
 * Requirement severity -- Warning condition; proceed but flag warning.
 */
25
const REQUIREMENT_WARNING = 1;
26
27
28
29

/**
 * Requirement severity -- Error condition; abort installation.
 */
30
const REQUIREMENT_ERROR = 2;
31

32
33
34
/**
 * File permission check -- File exists.
 */
35
const FILE_EXIST = 1;
36
37
38
39

/**
 * File permission check -- File is readable.
 */
40
const FILE_READABLE = 2;
41
42
43
44

/**
 * File permission check -- File is writable.
 */
45
const FILE_WRITABLE = 4;
46
47
48
49

/**
 * File permission check -- File is executable.
 */
50
const FILE_EXECUTABLE = 8;
51
52
53
54

/**
 * File permission check -- File does not exist.
 */
55
const FILE_NOT_EXIST = 16;
56
57
58
59

/**
 * File permission check -- File is not readable.
 */
60
const FILE_NOT_READABLE = 32;
61
62
63
64

/**
 * File permission check -- File is not writable.
 */
65
const FILE_NOT_WRITABLE = 64;
66
67
68
69

/**
 * File permission check -- File is not executable.
 */
70
const FILE_NOT_EXECUTABLE = 128;
71

72
/**
73
 * Loads .install files for installed modules to initialize the update system.
74
75
 */
function drupal_load_updates() {
76
77
78
79
  foreach (drupal_get_installed_schema_version(NULL, FALSE, TRUE) as $module => $schema_version) {
    if ($schema_version > -1) {
      module_load_install($module);
    }
80
81
82
  }
}

83
/**
84
 * Loads the installation profile, extracting its defined distribution name.
85
86
 *
 * @return
87
 *   The distribution name defined in the profile's .info.yml file. Defaults to
88
 *   "Drupal" if none is explicitly provided by the installation profile.
89
90
 *
 * @see install_profile_info()
91
 */
92
function drupal_install_profile_distribution_name() {
93
94
95
96
97
98
99
100
101
  // During installation, the profile information is stored in the global
  // installation state (it might not be saved anywhere yet).
  if (drupal_installation_attempted()) {
    global $install_state;
    return $install_state['profile_info']['distribution_name'];
  }
  // At all other times, we load the profile via standard methods.
  else {
    $profile = drupal_get_profile();
102
    $info = system_get_info('module', $profile);
103
104
    return $info['distribution_name'];
  }
105
106
107
}

/**
108
 * Detects all supported databases that are compiled into PHP.
109
110
111
112
113
 *
 * @return
 *  An array of database types compiled into PHP.
 */
function drupal_detect_database_types() {
114
115
116
117
118
119
120
121
122
123
  $databases = drupal_get_database_types();

  foreach ($databases as $driver => $installer) {
    $databases[$driver] = $installer->name();
  }

  return $databases;
}

/**
124
 * Returns all supported database installer objects that are compiled into PHP.
125
126
127
128
129
 *
 * @return
 *  An array of database installer objects compiled into PHP.
 */
function drupal_get_database_types() {
130
  $databases = array();
131
  $drivers = array();
132

133
  // We define a driver as a directory in /core/includes/database that in turn
134
  // contains a database.inc file. That allows us to drop in additional drivers
135
  // without modifying the installer.
136
  require_once DRUPAL_ROOT . '/core/includes/database.inc';
137
138
139
140
141
142
143
144
  // Allow any valid PHP identifier.
  // @see http://www.php.net/manual/en/language.variables.basics.php.
  $mask = '/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/';
  $files = file_scan_directory(DRUPAL_ROOT . '/core/lib/Drupal/Core/Database/Driver', $mask, array('recurse' => FALSE));
  if (is_dir(DRUPAL_ROOT . '/drivers/lib/Drupal/Driver/Database')) {
    $files += file_scan_directory(DRUPAL_ROOT . '/drivers/lib/Drupal/Driver/Database/', $mask, array('recurse' => FALSE));
  }
  foreach ($files as $file) {
145
    if (file_exists($file->uri . '/Install/Tasks.php')) {
146
147
      $drivers[$file->filename] = $file->uri;
    }
148
149
  }
  foreach ($drivers as $driver => $file) {
150
    $installer = db_installer_object($driver);
151
    if ($installer->installable()) {
152
      $databases[$driver] = $installer;
153
154
    }
  }
155

156
  // Usability: unconditionally put the MySQL driver on top.
157
158
159
160
161
  if (isset($databases['mysql'])) {
    $mysql_database = $databases['mysql'];
    unset($databases['mysql']);
    $databases = array('mysql' => $mysql_database) + $databases;
  }
162

163
164
165
  return $databases;
}

166
/**
167
 * Replaces values in settings.php with values in the submitted array.
168
 *
169
170
171
172
 * This function replaces values in place if possible, even for
 * multidimensional arrays. This way the old settings do not linger,
 * overridden and also the doxygen on a value remains where it should be.
 *
173
 * @param $settings
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 *   An array of settings that need to be updated. Multidimensional arrays
 *   are dumped up to a stdClass object. The object can have value, required
 *   and comment properties.
 *   @code
 *   $settings['config_directories'] = array(
 *     CONFIG_ACTIVE_DIRECTORY => array(
 *       'path' => (object) array(
 *         'value' => 'config__hash/active'
 *         'required' => TRUE,
 *       ),
 *     ),
 *     CONFIG_STAGING_DIRECTORY => array(
 *       'path' => (object) array(
 *         'value' => 'config_hash/staging',
 *         'required' => TRUE,
 *       ),
 *     ),
 *   );
 *   @endcode
 *   gets dumped as:
 *   @code
 *   $config_directories['active']['path'] = 'config__hash/active';
 *   $config_directories['staging']['path'] = 'config__hash/staging'
 *   @endcode
198
 */
199
200
201
202
function drupal_rewrite_settings($settings = array(), $settings_file = NULL) {
  if (!isset($settings_file)) {
    $settings_file = conf_path(FALSE) . '/settings.php';
  }
203
  // Build list of setting names and insert the values into the global namespace.
204
  $variable_names = array();
205
  foreach ($settings as $setting => $data) {
206
207
    _drupal_rewrite_settings_global($GLOBALS[$setting], $data);
    $variable_names['$'. $setting] = $setting;
208
  }
209
210
211
212
  $contents = file_get_contents(DRUPAL_ROOT . '/' . $settings_file);
  if ($contents !== FALSE) {
    // Step through each token in settings.php and replace any variables that
    // are in the passed-in array.
213
214
    $buffer = '';
    $state = 'default';
215
    foreach (token_get_all($contents) as $token) {
216
217
      if (is_array($token)) {
        list($type, $value) = $token;
218
      }
219
      else {
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
        $type = -1;
        $value = $token;
      }
      // Do not operate on whitespace.
      if (!in_array($type, array(T_WHITESPACE, T_COMMENT, T_DOC_COMMENT))) {
        switch ($state) {
          case 'default':
            if ($type === T_VARIABLE && isset($variable_names[$value])) {
              // This will be necessary to unset the dumped variable.
              $parent = &$settings;
              // This is the current index in parent.
              $index = $variable_names[$value];
              // This will be necessary for descending into the array.
              $current = &$parent[$index];
              $state = 'candidate_left';
            }
            break;
          case 'candidate_left':
            if ($value == '[') {
              $state = 'array_index';
            }
            if ($value == '=') {
              $state = 'candidate_right';
            }
            break;
          case 'array_index':
            if (_drupal_rewrite_settings_is_array_index($type, $value)) {
              $index = trim($value, '\'"');
              $state = 'right_bracket';
            }
            else {
              // $a[foo()] or $a[$bar] or something like that.
              throw new Exception('invalid array index');
            }
            break;
          case 'right_bracket':
            if ($value == ']') {
              if (isset($current[$index])) {
                // If the new settings has this index, descend into it.
                $parent = &$current;
                $current = &$parent[$index];
                $state = 'candidate_left';
              }
              else {
                // Otherwise, jump back to the default state.
                $state = 'wait_for_semicolon';
              }
            }
            else {
              // $a[1 + 2].
              throw new Exception('] expected');
            }
            break;
          case 'candidate_right':
            if (_drupal_rewrite_settings_is_simple($type, $value)) {
              $value = _drupal_rewrite_settings_dump_one($current);
              // Unsetting $current would not affect $settings at all.
              unset($parent[$index]);
              // Skip the semicolon because _drupal_rewrite_settings_dump_one() added one.
              $state = 'semicolon_skip';
            }
            else {
              $state = 'wait_for_semicolon';
            }
            break;
          case 'wait_for_semicolon':
            if ($value == ';') {
              $state = 'default';
            }
            break;
          case 'semicolon_skip':
            if ($value == ';') {
              $value = '';
              $state = 'default';
            }
            else {
              // If the expression was $a = 1 + 2; then we replaced 1 and
              // the + is unexpected.
              throw new Exception('Unepxected token after replacing value.');
            }
            break;
301
302
        }
      }
303
      $buffer .= $value;
304
    }
305
306
    foreach ($settings as $name => $setting) {
      $buffer .= _drupal_rewrite_settings_dump($setting, '$' . $name);
307
308
    }

309
310
    // Write the new settings file.
    if (file_put_contents(DRUPAL_ROOT . '/' . $settings_file, $buffer) === FALSE) {
311
      throw new Exception(st('Failed to modify %settings. Verify the file permissions.', array('%settings' => $settings_file)));
312
313
314
    }
  }
  else {
315
    throw new Exception(st('Failed to open %settings. Verify the file permissions.', array('%settings' => $settings_file)));
316
317
318
  }
}

319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
/**
 * Helper for drupal_rewrite_settings().
 *
 * Checks whether this token represents a scalar or NULL.
 *
 * @param int $type
 *   The token type
 *   @see token_name().
 * @param string $value
 *   The value of the token.
 *
 * @return bool
 *   TRUE if this token represents a scalar or NULL.
 */
function _drupal_rewrite_settings_is_simple($type, $value) {
  $is_integer = $type == T_LNUMBER;
  $is_float = $type == T_DNUMBER;
  $is_string = $type == T_CONSTANT_ENCAPSED_STRING;
  $is_boolean_or_null = $type == T_STRING && in_array(strtoupper($value), array('TRUE', 'FALSE', 'NULL'));
  return $is_integer || $is_float || $is_string || $is_boolean_or_null;
}


/**
 * Helper for drupal_rewrite_settings().
 *
 * Checks whether this token represents a valid array index: a number or a
 * stirng.
 *
 * @param int $type
 *   The token type
 *   @see token_name().
 *
 * @return bool
 *   TRUE if this token represents a number or a string.
 */
function _drupal_rewrite_settings_is_array_index($type) {
  $is_integer = $type == T_LNUMBER;
  $is_float = $type == T_DNUMBER;
  $is_string = $type == T_CONSTANT_ENCAPSED_STRING;
  return $is_integer || $is_float || $is_string;
}

/**
 * Helper for drupal_rewrite_settings().
 *
 * Makes the new settings global.
 *
 * @param array|NULL $ref
 *   A reference to a nested index in $GLOBALS.
 * @param array|object $variable
 *   The nested value of the setting being copied.
 */
function _drupal_rewrite_settings_global(&$ref, $variable) {
  if (is_object($variable)) {
    $ref = $variable->value;
  }
  else {
    foreach ($variable as $k => $v) {
      _drupal_rewrite_settings_global($ref[$k], $v);
    }
  }
}

/**
 * Helper for drupal_rewrite_settings().
 *
 * Dump the relevant value properties.
 *
 * @param array|object $variable
 *   The container for variable values.
 * @param string $variable_name
 *   Name of variable.
 * @return string
 *   A string containing valid PHP code of the variable suitable for placing
 *   into settings.php.
 */
function _drupal_rewrite_settings_dump($variable, $variable_name) {
  $return = '';
  if (is_object($variable)) {
    if (!empty($variable->required)) {
      $return .= _drupal_rewrite_settings_dump_one($variable, "$variable_name = ", "\n");
    }
  }
  else {
    foreach ($variable as $k => $v) {
      $return .= _drupal_rewrite_settings_dump($v, $variable_name . "['" . $k . "']");
    }
  }
  return $return;
}


/**
 * Helper for drupal_rewrite_settings().
 *
 * Dump the value of a value property and adds the comment if it exists.
 *
 * @param stdClass $variable
 *   A stdClass object with at least a value property.
 * @param string $prefix
 *   A string to prepend to the variable's value.
 * @param string $suffix
 *   A string to append to the variable's value.
 * @return string
 *   A string containing valid PHP code of the variable suitable for placing
 *   into settings.php.
 */
function _drupal_rewrite_settings_dump_one(\stdClass $variable, $prefix = '', $suffix = '') {
  $return = $prefix . var_export($variable->value, TRUE) . ';';
  if (!empty($variable->comment)) {
    $return .= ' // ' . $variable->comment;
  }
  $return .= $suffix;
  return $return;
}

436
437
438
439
440
441
/**
 * Creates the config directory and ensures it is operational.
 *
 * @see install_settings_form_submit()
 * @see update_prepare_d8_bootstrap()
 */
442
443
function drupal_install_config_directories() {
  global $config_directories;
444
445
446

  // Add a randomized config directory name to settings.php, unless it was
  // manually defined in the existing already.
447
  if (empty($config_directories)) {
448
    $config_directories_hash = drupal_hash_base64(drupal_random_bytes(55));
449
    $settings['config_directories'] = array(
450
451
452
453
      CONFIG_ACTIVE_DIRECTORY => array(
        'path' => (object) array(
          'value' => 'config_' . $config_directories_hash . '/active',
          'required' => TRUE,
454
        ),
455
456
457
458
459
      ),
      CONFIG_STAGING_DIRECTORY => array(
        'path' => (object) array(
          'value' => 'config_' . $config_directories_hash . '/staging',
          'required' => TRUE,
460
        ),
461
      ),
462
463
464
465
466
    );
    // Rewrite settings.php, which also sets the value as global variable.
    drupal_rewrite_settings($settings);
  }

467
  // Ensure the config directories exist or can be created, and are writable.
468
  foreach (array(CONFIG_ACTIVE_DIRECTORY, CONFIG_STAGING_DIRECTORY) as $config_type) {
469
470
471
472
473
474
    // This should never fail, since if the config directory was specified in
    // settings.php it will have already been created and verified earlier, and
    // if it wasn't specified in settings.php, it is created here inside the
    // public files directory, which has already been verified to be writable
    // itself. But if it somehow fails anyway, the installation cannot proceed.
    // Bail out using a similar error message as in system_requirements().
475
476
477
478
479
480
    if (!install_ensure_config_directory($config_type)) {
      throw new Exception(st('The directory %directory could not be created or could not be made writable. To proceed with the installation, either create the directory and modify its permissions manually or ensure that the installer has the permissions to create it automatically. For more information, see the <a href="@handbook_url">online handbook</a>.', array(
        '%directory' => config_get_config_directory($config_type),
        '@handbook_url' => 'http://drupal.org/server-permissions',
      )));
    }
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495

    // Put a README.txt into each config directory. This is required so that
    // they can later be added to git. Since these directories are auto-
    // created, we have to write out the README rather than just adding it
    // to the drupal core repo.
    switch ($config_type) {
      case CONFIG_ACTIVE_DIRECTORY:
        $text = 'This directory contains the active configuration for your Drupal site. To move this configuration between environments, contents from this directory should be placed in the staging directory on the target server. To make this configuration active, see admin/config/development/sync on the target server.';
        break;
      case CONFIG_STAGING_DIRECTORY:
        $text = 'This directory contains configuration to be imported into your Drupal site. To make this configuration active, see admin/config/development/sync.';
        break;
    }
    $text .=  ' For information about deploying configuration between servers, see http://drupal.org/documentation/administer/config';
    file_put_contents(config_get_config_directory($config_type) . '/README.txt', $text);
496
497
498
  }
}

499
/**
500
 * Checks whether a config directory exists and is writable.
501
 *
502
 * This partially duplicates install_ensure_config_directory(), but is required
503
504
 * since the installer would create the config directory too early in the
 * installation process otherwise (e.g., when only visiting install.php when
505
506
 * there is a settings.php already, but not actually executing the
 * installation).
507
508
509
510
511
512
513
514
515
516
517
518
519
 *
 * @param string $type
 *   Type of config directory to return. Drupal core provides 'active' and
 *   'staging'.
 *
 * @return bool
 *   TRUE if the config directory exists and is writable.
 */
function install_verify_config_directory($type) {
  global $config_directories;
  if (!isset($config_directories[$type])) {
    return FALSE;
  }
520
521
522
523
524
525
526
527
528
529
  // config_get_config_directory() throws an exception when the passed $type
  // does not exist in $config_directories. This can happen if there is a
  // prepared settings.php that defines $config_directories already.
  try {
    $config_directory = config_get_config_directory($type);
    if (is_dir($config_directory) && is_writable($config_directory)) {
      return TRUE;
    }
  }
  catch (\Exception $e) {
530
531
532
533
  }
  return FALSE;
}

534
535
/**
 * Ensures that the config directory exists and is writable, or can be made so.
536
537
538
539
540
541
542
 *
 * @param string $type
 *   Type of config directory to return. Drupal core provides 'active' and
 *   'staging'.
 *
 * @return bool
 *   TRUE if the config directory exists and is writable.
543
 */
544
function install_ensure_config_directory($type) {
545
  // The config directory must be defined in settings.php.
546
547
  global $config_directories;
  if (!isset($config_directories[$type])) {
548
549
550
551
552
    return FALSE;
  }
  // The logic here is similar to that used by system_requirements() for other
  // directories that the installer creates.
  else {
553
    $config_directory = config_get_config_directory($type);
554
555
556
557
    return file_prepare_directory($config_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS);
  }
}

558
/**
559
 * Verifies that all dependencies are met for a given installation profile.
560
 *
561
562
 * @param $install_state
 *   An array of information about the current installation state.
563
 *
Steven Wittens's avatar
Steven Wittens committed
564
565
 * @return
 *   The list of modules to install.
566
 */
567
function drupal_verify_profile($install_state) {
568
569
  include_once DRUPAL_ROOT . '/core/includes/file.inc';
  include_once DRUPAL_ROOT . '/core/includes/common.inc';
570

571
572
  $profile = $install_state['parameters']['profile'];
  $profile_file = $install_state['profiles'][$profile]->uri;
573
574

  if (!isset($profile) || !file_exists($profile_file)) {
575
    throw new Exception(install_no_profile_error());
576
  }
577
  $info = $install_state['profile_info'];
578

579
580
  // Get a list of modules that exist in Drupal's assorted subdirectories.
  $present_modules = array();
581
  foreach (drupal_system_listing('/^' . DRUPAL_PHP_FUNCTION_PATTERN . '\.module$/', 'modules') as $present_module) {
582
583
584
    $present_modules[] = $present_module->name;
  }

585
586
  // The installation profile is also a module, which needs to be installed
  // after all the other dependencies have been installed.
587
588
  $present_modules[] = drupal_get_profile();

589
  // Verify that all of the profile's required modules are present.
590
  $missing_modules = array_diff($info['dependencies'], $present_modules);
591
592

  $requirements = array();
593

594
  if (count($missing_modules)) {
595
    $modules = array();
596
    foreach ($missing_modules as $module) {
597
      $modules[] = '<span class="admin-missing">' . drupal_ucfirst($module) . '</span>';
Steven Wittens's avatar
Steven Wittens committed
598
    }
599
600
601
602
    $requirements['required_modules'] = array(
      'title'       => st('Required modules'),
      'value'       => st('Required modules not found.'),
      'severity'    => REQUIREMENT_ERROR,
603
      'description' => st('The following modules are required but were not found. Move them into the appropriate modules subdirectory, such as <em>/modules</em>. Missing modules: !modules', array('!modules' => implode(', ', $modules))),
604
    );
Steven Wittens's avatar
Steven Wittens committed
605
  }
606
  return $requirements;
Steven Wittens's avatar
Steven Wittens committed
607
}
608

609
/**
610
 * Installs the system module.
611
612
613
614
615
 *
 * Separated from the installation of other modules so core system
 * functions can be made available while other modules are installed.
 */
function drupal_install_system() {
616
617
  // Create tables.
  drupal_install_schema('system');
618
619
620
621
622
623
624
625
626

  if (drupal_container()->has('kernel')) {
    $kernel = drupal_container()->get('kernel');
  }
  else {
    // Immediately boot a kernel to have real services ready.
    $kernel = new DrupalKernel('install', FALSE, drupal_classloader(), FALSE);
    $kernel->boot();
  }
627

628
  $system_path = drupal_get_path('module', 'system');
629
  require_once DRUPAL_ROOT . '/' . $system_path . '/system.install';
Steven Wittens's avatar
Steven Wittens committed
630
631
  $system_versions = drupal_get_schema_versions('system');
  $system_version = $system_versions ? max($system_versions) : SCHEMA_INSTALLED;
632
  Drupal::keyValue('system.schema')->set('system', $system_version);
633
634
635
636
637
638
639
640
641

  // System module needs to be enabled and the system/module lists need to be
  // reset first in order to allow config_install_default_config() to invoke
  // config import callbacks.
  // @todo Installation profiles may override the system.module config object.
  config('system.module')
    ->set('enabled.system', 0)
    ->save();

642
643
644
  // Update the module list to include it.
  drupal_container()->get('module_handler')->setModuleList(array('system' => $system_path . '/system.module'));

645
  config_install_default_config('module', 'system');
646
647

  module_invoke('system', 'install');
648
649
}

650
/**
651
 * Verifies the state of the specified file.
652
653
654
655
656
657
658
 *
 * @param $file
 *   The file to check for.
 * @param $mask
 *   An optional bitmask created from various FILE_* constants.
 * @param $type
 *   The type of file. Can be file (default), dir, or link.
659
 *
660
 * @return
661
 *   TRUE on success or FALSE on failure. A message is set for the latter.
662
663
664
665
666
667
668
669
670
 */
function drupal_verify_install_file($file, $mask = NULL, $type = 'file') {
  $return = TRUE;
  // Check for files that shouldn't be there.
  if (isset($mask) && ($mask & FILE_NOT_EXIST) && file_exists($file)) {
    return FALSE;
  }
  // Verify that the file is the type of file it is supposed to be.
  if (isset($type) && file_exists($file)) {
671
    $check = 'is_' . $type;
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
    if (!function_exists($check) || !$check($file)) {
      $return = FALSE;
    }
  }

  // Verify file permissions.
  if (isset($mask)) {
    $masks = array(FILE_EXIST, FILE_READABLE, FILE_WRITABLE, FILE_EXECUTABLE, FILE_NOT_READABLE, FILE_NOT_WRITABLE, FILE_NOT_EXECUTABLE);
    foreach ($masks as $current_mask) {
      if ($mask & $current_mask) {
        switch ($current_mask) {
          case FILE_EXIST:
            if (!file_exists($file)) {
              if ($type == 'dir') {
                drupal_install_mkdir($file, $mask);
              }
              if (!file_exists($file)) {
                $return = FALSE;
              }
            }
            break;
          case FILE_READABLE:
            if (!is_readable($file) && !drupal_install_fix_file($file, $mask)) {
              $return = FALSE;
            }
            break;
          case FILE_WRITABLE:
            if (!is_writable($file) && !drupal_install_fix_file($file, $mask)) {
              $return = FALSE;
            }
            break;
          case FILE_EXECUTABLE:
            if (!is_executable($file) && !drupal_install_fix_file($file, $mask)) {
              $return = FALSE;
            }
            break;
          case FILE_NOT_READABLE:
            if (is_readable($file) && !drupal_install_fix_file($file, $mask)) {
              $return = FALSE;
            }
            break;
          case FILE_NOT_WRITABLE:
            if (is_writable($file) && !drupal_install_fix_file($file, $mask)) {
              $return = FALSE;
            }
            break;
          case FILE_NOT_EXECUTABLE:
            if (is_executable($file) && !drupal_install_fix_file($file, $mask)) {
              $return = FALSE;
            }
            break;
        }
      }
    }
  }
  return $return;
}

/**
731
 * Creates a directory with the specified permissions.
732
 *
733
 * @param $file
734
 *  The name of the directory to create;
735
 * @param $mask
736
737
738
 *  The permissions of the directory to create.
 * @param $message
 *  (optional) Whether to output messages. Defaults to TRUE.
739
 *
740
741
742
743
744
745
746
747
748
749
 * @return
 *  TRUE/FALSE whether or not the directory was successfully created.
 */
function drupal_install_mkdir($file, $mask, $message = TRUE) {
  $mod = 0;
  $masks = array(FILE_READABLE, FILE_WRITABLE, FILE_EXECUTABLE, FILE_NOT_READABLE, FILE_NOT_WRITABLE, FILE_NOT_EXECUTABLE);
  foreach ($masks as $m) {
    if ($mask & $m) {
      switch ($m) {
        case FILE_READABLE:
750
          $mod |= 0444;
751
752
          break;
        case FILE_WRITABLE:
753
          $mod |= 0222;
754
755
          break;
        case FILE_EXECUTABLE:
756
          $mod |= 0111;
757
758
759
760
761
          break;
      }
    }
  }

762
  if (@drupal_mkdir($file, $mod)) {
763
764
765
766
767
768
769
770
    return TRUE;
  }
  else {
    return FALSE;
  }
}

/**
771
 * Attempts to fix file permissions.
772
 *
773
774
775
776
777
778
779
780
781
 * The general approach here is that, because we do not know the security
 * setup of the webserver, we apply our permission changes to all three
 * digits of the file permission (i.e. user, group and all).
 *
 * To ensure that the values behave as expected (and numbers don't carry
 * from one digit to the next) we do the calculation on the octal value
 * using bitwise operations. This lets us remove, for example, 0222 from
 * 0700 and get the correct value of 0500.
 *
782
783
784
785
786
787
 * @param $file
 *  The name of the file with permissions to fix.
 * @param $mask
 *  The desired permissions for the file.
 * @param $message
 *  (optional) Whether to output messages. Defaults to TRUE.
788
 *
789
790
791
792
 * @return
 *  TRUE/FALSE whether or not we were able to fix the file's permissions.
 */
function drupal_install_fix_file($file, $mask, $message = TRUE) {
793
794
795
796
797
  // If $file does not exist, fileperms() issues a PHP warning.
  if (!file_exists($file)) {
    return FALSE;
  }

798
  $mod = fileperms($file) & 0777;
799
  $masks = array(FILE_READABLE, FILE_WRITABLE, FILE_EXECUTABLE, FILE_NOT_READABLE, FILE_NOT_WRITABLE, FILE_NOT_EXECUTABLE);
800
801
802
803
804

  // FILE_READABLE, FILE_WRITABLE, and FILE_EXECUTABLE permission strings
  // can theoretically be 0400, 0200, and 0100 respectively, but to be safe
  // we set all three access types in case the administrator intends to
  // change the owner of settings.php after installation.
805
806
807
808
809
  foreach ($masks as $m) {
    if ($mask & $m) {
      switch ($m) {
        case FILE_READABLE:
          if (!is_readable($file)) {
810
            $mod |= 0444;
811
812
813
814
          }
          break;
        case FILE_WRITABLE:
          if (!is_writable($file)) {
815
            $mod |= 0222;
816
817
818
819
          }
          break;
        case FILE_EXECUTABLE:
          if (!is_executable($file)) {
820
            $mod |= 0111;
821
822
823
824
          }
          break;
        case FILE_NOT_READABLE:
          if (is_readable($file)) {
825
            $mod &= ~0444;
826
827
828
829
          }
          break;
        case FILE_NOT_WRITABLE:
          if (is_writable($file)) {
830
            $mod &= ~0222;
831
832
833
834
          }
          break;
        case FILE_NOT_EXECUTABLE:
          if (is_executable($file)) {
835
            $mod &= ~0111;
836
837
838
839
840
841
          }
          break;
      }
    }
  }

842
843
844
845
  // chmod() will work if the web server is running as owner of the file.
  // If PHP safe_mode is enabled the currently executing script must also
  // have the same owner.
  if (@chmod($file, $mod)) {
846
847
848
849
850
851
852
    return TRUE;
  }
  else {
    return FALSE;
  }
}

853
/**
854
 * Sends the user to a different installer page.
855
856
 *
 * This issues an on-site HTTP redirect. Messages (and errors) are erased.
857
858
859
860
861
 *
 * @param $path
 *   An installer path.
 */
function install_goto($path) {
862
  global $base_url;
863
  include_once DRUPAL_ROOT . '/core/includes/common.inc';
864
  header('Location: ' . $base_url . '/' . $path);
865
  header('Cache-Control: no-cache'); // Not a permanent redirect.
866
  drupal_exit();
867
868
}

869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
/**
 * Returns the URL of the current script, with modified query parameters.
 *
 * This function can be called by low-level scripts (such as install.php and
 * update.php) and returns the URL of the current script. Existing query
 * parameters are preserved by default, but new ones can optionally be merged
 * in.
 *
 * This function is used when the script must maintain certain query parameters
 * over multiple page requests in order to work correctly. In such cases (for
 * example, update.php, which requires the 'continue=1' parameter to remain in
 * the URL throughout the update process if there are any requirement warnings
 * that need to be bypassed), using this function to generate the URL for links
 * to the next steps of the script ensures that the links will work correctly.
 *
 * @param $query
 *   (optional) An array of query parameters to merge in to the existing ones.
 *
 * @return
 *   The URL of the current script, with query parameters modified by the
 *   passed-in $query. The URL is not sanitized, so it still needs to be run
 *   through check_url() if it will be used as an HTML attribute value.
 *
 * @see drupal_requirements_url()
 */
function drupal_current_script_url($query = array()) {
  $uri = $_SERVER['SCRIPT_NAME'];
  $query = array_merge(drupal_get_query_parameters(), $query);
  if (!empty($query)) {
    $uri .= '?' . drupal_http_build_query($query);
  }
  return $uri;
}

/**
 * Returns a URL for proceeding to the next page after a requirements problem.
 *
 * This function can be called by low-level scripts (such as install.php and
 * update.php) and returns a URL that can be used to attempt to proceed to the
 * next step of the script.
 *
 * @param $severity
 *   The severity of the requirements problem, as returned by
 *   drupal_requirements_severity().
 *
 * @return
 *   A URL for attempting to proceed to the next step of the script. The URL is
 *   not sanitized, so it still needs to be run through check_url() if it will
 *   be used as an HTML attribute value.
 *
 * @see drupal_current_script_url()
 */
function drupal_requirements_url($severity) {
  $query = array();
  // If there are no errors, only warnings, append 'continue=1' to the URL so
  // the user can bypass this screen on the next page load.
  if ($severity == REQUIREMENT_WARNING) {
    $query['continue'] = 1;
  }
  return drupal_current_script_url($query);
}

931
/**
932
 * Translates a string when some systems are not available.
933
934
 *
 * Used during the install process, when database, theme, and localization
935
 * system is possibly not yet available.
936
 *
937
938
939
940
 * Use t() if your code will never run during the Drupal installation phase.
 * Use st() if your code will only run during installation and never any other
 * time. Use get_t() if your code could run in either circumstance.
 *
941
 * @see t()
942
 * @see get_t()
943
 * @ingroup sanitization
944
 */
945
function st($string, array $args = array(), array $options = array()) {
946
  static $strings = NULL;
947
  global $install_state;
drumm's avatar
drumm committed
948

949
950
951
952
  if (empty($options['context'])) {
    $options['context'] = '';
  }

953
954
  if (!isset($strings)) {
    $strings = array();
955
    if (isset($install_state['parameters']['langcode'])) {
956
957
      // If the given langcode was selected, there should be at least one .po
      // file with its name in the pattern drupal-$version.$langcode.po.
958
      // This might or might not be the entire filename. It is also possible
959
      // that multiple files end with the same suffix, even if unlikely.
960
961
      $files = install_find_translation_files($install_state['parameters']['langcode']);
      if (!empty($files)) {
962
963
964
        // Register locale classes with the classloader. Locale module is not
        // yet enabled at this stage, so this is not happening automatically.
        drupal_classloader_register('locale', drupal_get_path('module', 'locale'));
965
        $strings = Gettext::filesToArray($install_state['parameters']['langcode'], $files);
966
      }
967
    }
drumm's avatar
drumm committed
968
969
  }

970
  require_once DRUPAL_ROOT . '/core/includes/theme.inc';
971
  // Transform arguments before inserting them
972
  foreach ($args as $key => $value) {
973
974
975
976
977
978
979
980
    switch ($key[0]) {
      // Escaped only
      case '@':
        $args[$key] = check_plain($value);
        break;
      // Escaped and placeholder
      case '%':
      default:
981
        $args[$key] = '<em>' . check_plain($value) . '</em>';
982
983
984
985
        break;
      // Pass-through
      case '!':
    }
986
  }
987
  return strtr((!empty($strings[$options['context']][$string]) ? $strings[$options['context']][$string] : $string), $args);
988
}
989
990

/**
991
 * Checks an installation profile's requirements.
992
 *
993
 * @param string $profile
994
 *   Name of installation profile to check.
995
996
997
998
 * @param array $install_state
 *   The current state in the install process.
 *
 * @return array
999
 *   Array of the installation profile's requirements.
1000
 */
1001
function drupal_check_profile($profile, array $install_state) {
1002
  include_once DRUPAL_ROOT . '/core/includes/file.inc';
1003

1004
  $profile_file = $install_state['profiles'][$profile]->uri;
1005
1006

  if (!isset($profile) || !file_exists($profile_file)) {
1007
    throw new Exception(install_no_profile_error());
1008
1009
  }

1010
  $info = install_profile_info($profile);
1011

1012
  // Collect requirement testing results.
1013
  $requirements = array();
1014
1015
1016
  foreach ($info['dependencies'] as $module) {
    module_load_install($module);
    $function = $module . '_requirements';
1017
1018
    if (function_exists($function)) {
      $requirements = array_merge($requirements, $function('install'));
1019
    }
1020
1021
1022
1023
1024
  }
  return $requirements;
}

/**
1025
 * Extracts the highest severity from the requirements array.
1026
1027
 *
 * @param $requirements
1028
 *   An array of requirements, in the same format as is returned by
1029
 *   hook_requirements().
1030
 *
1031
1032
 * @return
 *   The highest severity in the array.
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
 */
function drupal_requirements_severity(&$requirements) {
  $severity = REQUIREMENT_OK;
  foreach ($requirements as $requirement) {
    if (isset($requirement['severity'])) {
      $severity = max($severity, $requirement['severity']);
    }
  }
  return $severity;
}

/**
1045
 * Checks a module's requirements.
1046
1047
1048
 *
 * @param $module
 *   Machine name of module to check.
1049
 *
1050
 * @return
1051
 *   TRUE or FALSE, depending on whether the requirements are met.
1052
1053
 */
function drupal_check_module($module) {
1054
1055
  module_load_install($module);
  if (module_hook($module, 'requirements')) {
1056
1057
1058
1059
1060
1061
    // Check requirements
    $requirements = module_invoke($module, 'requirements', 'install');
    if (is_array($requirements) && drupal_requirements_severity($requirements) == REQUIREMENT_ERROR) {
      // Print any error messages
      foreach ($requirements as $requirement) {
        if (isset($requirement['severity']) && $requirement['severity'] == REQUIREMENT_ERROR) {
1062
1063
          $message = $requirement['description'];
          if (isset($requirement['value']) && $requirement['value']) {
1064
            $message .= ' (' . t('Currently using !item !version', array('!item' => $requirement['title'], '!version' => $requirement['value'])) . ')';
1065
1066
          }
          drupal_set_message($message, 'error');
1067
1068
1069
1070
1071
1072
1073
        }
      }
      return FALSE;
    }
  }
  return TRUE;
}
1074
1075

/**
1076
 * Retrieves information about an installation profile from its .info.yml file.
1077
 *
1078
1079
 * The information stored in a profile .info.yml file is similar to that stored
 * in a normal Drupal module .info.yml file. For example:
1080
 * - name: The real name of the installation profile for display purposes.
1081
 * - description: A brief description of the profile.
1082
1083
 * - dependencies: An array of shortnames of other modules that this install
 *   profile requires.
1084
 *
1085
1086
1087
 * Additional, less commonly-used information that can appear in a
 * profile.info.yml file but not in a normal Drupal module .info.yml file
 * includes:
1088
1089
1090
 * - distribution_name: The name of the Drupal distribution that is being
 *   installed, to be shown throughout the installation process. Defaults to
 *   'Drupal'.
1091
1092
1093
1094
1095
1096
 * - exclusive: If the install profile is intended to be the only eligible
 *   choice in a distribution, setting exclusive = TRUE will auto-select it
 *   during installation, and the install profile selection screen will be
 *   skipped. If more than one profile is found where exclusive = TRUE then
 *   this property will have no effect and the profile selection screen will
 *   be shown as normal with all available profiles shown.
1097
 *
1098
1099
1100
1101
 * Note that this function does an expensive file system scan to get info file
 * information for dependencies. If you only need information from the info
 * file itself, use system_get_info().
 *
1102
 * Example of .info.yml file:
1103
 * @code
1104
1105
 *    name = Minimal
 *    description = Start fresh, with only a few modules enabled.
1106
1107
 *    dependencies[] = block
 *    dependencies[] = dblog
1108
 * @endcode
1109
 *
1110
 * @param $profile
1111
 *   Name of profile.
1112
1113
 * @param $langcode
 *   Language code (if any).
1114
 *
1115
1116
 * @return
 *   The info array.
1117
 */
1118
function install_profile_info($profile, $langcode = 'en') {
1119
1120
1121
1122
1123
1124
1125
  $cache = &drupal_static(__FUNCTION__, array());

  if (!isset($cache[$profile])) {
    // Set defaults for module info.
    $defaults = array(
      'dependencies' => array(),
      'description' => '',
1126
      'distribution_name' => 'Drupal',
1127
      'version' => NULL,
1128
      'hidden' => FALSE,
1129
1130
      'php' => DRUPAL_MINIMUM_PHP,
    );
1131
    $profile_file = drupal_get_path('profile', $profile) . "/$profile.info.yml";
1132
1133
    $info = drupal_parse_info_file($profile_file);
    $info += $defaults;
1134
    $info['dependencies'] = array_unique(array_merge(
1135
1136
      drupal_required_modules(),
      $info['dependencies'],
1137
      ($langcode != 'en' && !empty($langcode) ? array('locale') : array()))
1138
    );
1139
1140
1141
1142
1143

    // drupal_required_modules() includes the current profile as a dependency.
    // Since a module can't depend on itself we remove that element of the array.
    array_shift($info['dependencies']);

1144
1145
1146
    $cache[$profile] = $info;
  }
  return $cache[$profile];
1147
1148
}

1149
1150
1151
1152
1153
/**
 * Ensures the environment for a Drupal database on a predefined connection.
 *
 * This will run tasks that check that Drupal can perform all of the functions
 * on a database, that Drupal needs. Tasks include simple checks like CREATE
1154
 * TABLE to database specific functions like stored procedures and client
1155
1156
1157
 * encoding.
 */
function db_run_tasks($driver) {
1158
  db_installer_object($driver)->runTasks();
1159
  return TRUE;
1160
}
1161
1162
1163
1164
1165
1166
1167
1168

/**
 * Returns a database installer object.
 *
 * @param $driver
 *   The name of the driver.
 */
function db_installer_object($driver) {
1169
1170
  // We cannot use Database::getConnection->getDriverClass() here, because
  // the connection object is not yet functional.
1171
  $task_class = "Drupal\\Core\\Database\\Driver\\{$driver}\\Install\\Tasks";
1172
1173
1174
1175
1176
1177
1178
  if (class_exists($task_class)) {
    return new $task_class();
  }
  else {
    $task_class = "Drupal\\Driver\\Database\\{$driver}\\Install\\Tasks";
    return new $task_class();
  }
1179
}