Newer
Older
<?php
/**
* Configuration of SimpleSAMLphp
Andreas Åkre Solberg
committed
*
Andreas Åkre Solberg
committed
* @author Andreas Aakre Solberg, UNINETT AS. <andreas.solberg@uninett.no>
Andreas Åkre Solberg
committed
* @package simpleSAMLphp
* @version $Id$
*/
class SimpleSAML_Configuration {
/**
* A default value which means that the given option is required.
*/
const REQUIRED_OPTION = '___REQUIRED_OPTION___';
/**
* Associative array with mappings from instance-names to configuration objects.
*/
Andreas Åkre Solberg
committed
private static $instance = array();
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/**
* Configration directories.
*
* This associative array contains the mappings from configuration sets to
* configuration directories.
*/
private static $configDirs = array();
/**
* Cache of loaded configuration files.
*
* The index in the array is the full path to the file.
*/
private static $loadedConfigs = array();
/**
* The configuration array.
*/
private $configuration;
/**
* The location which will be given when an error occurs.
*/
private $location;
/**
* The file this configuration was loaded from.
*/
private $filename = NULL;
/**
* Initializes a configuration from the given array.
*
* @param array $config The configuration array.
* @param string $location The location which will be given when an error occurs.
*/
public function __construct($config, $location) {
assert('is_array($config)');
assert('is_string($location)');
$this->configuration = $config;
$this->location = $location;
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
/**
* Load the given configuration file.
*
* @param string $filename The full path of the configuration file.
* @return SimpleSAML_Configuration The configuration file. An exception will be thrown if the
* configuration file is missing.
*/
private static function loadFromFile($filename) {
assert('is_string($filename)');
if (array_key_exists($filename, self::$loadedConfigs)) {
return self::$loadedConfigs[$filename];
}
if (!file_exists($filename)) {
throw new Exception('Missing configuration file: ' . $filename);
}
$config = 'UNINITIALIZED';
/* The file initializes a variable named '$config'. */
require_once($filename);
/* Check that $config is initialized to an array. */
if (!is_array($config)) {
throw new Exception('Invalid configuration file: ' . $filename);
}
if (array_key_exists('override.host', $config)) {
$host = SimpleSAML_Utilities::getSelfHost();
if (array_key_exists($host, $config['override.host'])) {
$ofs = $config['override.host'][$host];
foreach (SimpleSAML_Utilities::arrayize($ofs) AS $of) {
$overrideFile = dirname($filename) . '/' . $of;
if (!file_exists($overrideFile)) {
throw new Exception('Config file [' . $filename . '] requests override for host ' . $host . ' but file does not exists [' . $of . ']');
}
require($overrideFile);
}
}
}
$cfg = new SimpleSAML_Configuration($config, $filename);
$cfg->filename = $filename;
self::$loadedConfigs[$filename] = $cfg;
return $cfg;
}
/**
* Set the directory for configuration files for the given configuration set.
*
* @param string $path The directory which contains the configuration files.
* @param string $configSet The configuration set. Defaults to 'simplesaml'.
*/
public static function setConfigDir($path, $configSet = 'simplesaml') {
assert('is_string($path)');
assert('is_string($configSet)');
self::$configDirs[$configSet] = $path;
}
/**
* Load a configuration file from a configuration set.
*
* @param string $filename The name of the configuration file.
* @param string $configSet The configuration set. Optional, defaults to 'simplesaml'.
*/
public static function getConfig($filename = 'config.php', $configSet = 'simplesaml') {
assert('is_string($filename)');
assert('is_string($configSet)');
if (!array_key_exists($configSet, self::$configDirs)) {
throw new Exception('Configuration set \'' . $configSet . '\' not initialized.');
}
$dir = self::$configDirs[$configSet];
$filePath = $dir . '/' . $filename;
return self::loadFromFile($filePath);
}
/**
* Loads a configuration from the given array.
*
* @param array $config The configuration array.
* @param string $location The location which will be given when an error occurs. Optional.
* @return SimpleSAML_Configuration The configuration object.
*/
public static function loadFromArray($config, $location = '[ARRAY]') {
assert('is_array($config)');
assert('is_string($location)');
return new SimpleSAML_Configuration($config, $location);
}
/**
* Get a configuration file by its instance name.
*
* This function retrieves a configuration file by its instance name. The instance
* name is initialized by the init function, or by copyFromBase function.
*
* If no configuration file with the given instance name is found, an exception will
* be thrown.
*
* @param string $instancename The instance name of the configuration file. Depreceated.
* @return SimpleSAML_Configuration The configuration object.
*/
Andreas Åkre Solberg
committed
public static function getInstance($instancename = 'simplesaml') {
assert('is_string($instancename)');
if ($instancename === 'simplesaml') {
return self::getConfig();
}
Andreas Åkre Solberg
committed
if (!array_key_exists($instancename, self::$instance))
throw new Exception('Configuration with name ' . $instancename . ' is not initialized.');
return self::$instance[$instancename];
/**
* Initialize a instance name with the given configuration file.
*
* @see setConfigDir()
* @depreceated This function is superseeded by the setConfigDir function.
*/
public static function init($path, $instancename = 'simplesaml', $configfilename = 'config.php') {
assert('is_string($path)');
assert('is_string($instancename)');
assert('is_string($configfilename)');
if ($instancename === 'simplesaml') {
/* For backwards compatibility. */
self::setConfigDir($path, 'simplesaml');
}
/* Check if we already have loaded the given config - return the existing instance if we have. */
if(array_key_exists($instancename, self::$instance)) {
return self::$instance[$instancename];
}
self::$instance[$instancename] = self::loadFromFile($path . '/' . $configfilename);
/**
* Load a configuration file which is located in the same directory as this configuration file.
*
* @see getConfig()
* @depreceated This function is superseeded by the getConfig() function.
*/
Andreas Åkre Solberg
committed
public function copyFromBase($instancename, $filename) {
assert('is_string($instancename)');
assert('is_string($filename)');
assert('$this->filename !== NULL');
/* Check if we already have loaded the given config - return the existing instance if we have. */
if(array_key_exists($instancename, self::$instance)) {
return self::$instance[$instancename];
}
$dir = dirname($this->filename);
if ($instancename === 'simplesaml') {
/* For backwards compatibility. */
self::setConfigDir($path, 'simplesaml');
self::$instance[$instancename] = self::loadFromFile($dir . '/' . $filename);
return self::$instance[$instancename];
public function getVersion($verbose = FALSE) {
/**
* Retrieve a configuration option set in config.php.
* @param $name Name of the configuration option.
* @param $default Default value of the configuration option. This parameter will default to NULL if not
* specified. This can be set to SimpleSAML_Configuration::REQUIRED_OPTION, which will
* cause an exception to be thrown if the option isn't found.
* @return The configuration option with name $name, or $default if the option was not found.
*/
public function getValue($name, $default = NULL) {
Olav Morken
committed
/* Return the default value if the option is unset. */
Olav Morken
committed
if (!array_key_exists($name, $this->configuration)) {
if($default === self::REQUIRED_OPTION) {
throw new Exception($this->location . ': Could not retrieve the required option ' .
var_export($name, TRUE));
Olav Morken
committed
}
return $this->configuration[$name];
}
Andreas Åkre Solberg
committed
/**
* Check whether an key in the configuration exists...
*/
public function hasValue($name) {
return array_key_exists($name, $this->configuration);
}
/**
* Check whether an key in the configuration exists...
*/
public function hasValueOneOf($names) {
foreach($names AS $name) if ($this->hasValue($name)) return TRUE;
return FALSE;
}
Andreas Åkre Solberg
committed
public function getBaseURL() {
if (preg_match('/^\*(.*)$/', $this->getValue('baseurlpath', ''), $matches)) {
return SimpleSAML_Utilities::getFirstPathElement(false) . $matches[1];
}
return $this->getValue('baseurlpath', '');
}
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
/**
* This function resolves a path which may be relative to the
* simpleSAMLphp base directory.
*
* The path will never end with a '/'.
*
* @param $path The path we should resolve. This option may be NULL.
* @return $path if $path is an absolute path, or $path prepended with
* the base directory of this simpleSAMLphp installation. We
* will return NULL if $path is NULL.
*/
public function resolvePath($path) {
if($path === NULL) {
return NULL;
}
assert('is_string($path)');
/* Prepend path with basedir if it doesn't start with
* a slash. We assume getBaseDir ends with a slash.
*/
if ($path[0] !== '/') $path = $this->getBaseDir() . $path;
/* Remove trailing slashes. */
while (substr($path, -1) === '/') {
$path = substr($path, 0, -1);
}
return $path;
}
/**
* Retrieve a path configuration option set in config.php.
Andreas Åkre Solberg
committed
* The function will always return an absolute path unless the
* option is not set. It will then return the default value.
*
* It checks if the value starts with a slash, and prefixes it
* with the value from getBaseDir if it doesn't.
*
* @param $name Name of the configuration option.
* @param $default Default value of the configuration option.
* This parameter will default to NULL if not specified.
* @return The path configuration option with name $name, or $default if
Andreas Åkre Solberg
committed
* the option was not found.
*/
public function getPathValue($name, $default = NULL) {
/* Return the default value if the option is unset. */
if (!array_key_exists($name, $this->configuration)) {
$path = $default;
} else {
$path = $this->configuration[$name];
Andreas Åkre Solberg
committed
}
return $this->resolvePath($path) . '/';
Andreas Åkre Solberg
committed
}
/**
* Retrieve the base directory for this simpleSAMLphp installation.
* This function first checks the 'basedir' configuration option. If
* this option is undefined or NULL, then we fall back to looking at
* the current filename.
*
* @return The absolute path to the base directory for this simpleSAMLphp
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
* installation. This path will always end with a slash.
*/
public function getBaseDir() {
/* Check if a directory is configured in the configuration
* file.
*/
$dir = $this->getValue('basedir');
if($dir !== NULL) {
/* Add trailing slash if it is missing. */
if(substr($dir, -1) !== '/') {
$dir .= '/';
}
return $dir;
}
/* The directory wasn't set in the configuration file. Our
* path is <base directory>/lib/SimpleSAML/Configuration.php
*/
$dir = __FILE__;
assert('basename($dir) === "Configuration.php"');
$dir = dirname($dir);
assert('basename($dir) === "SimpleSAML"');
$dir = dirname($dir);
assert('basename($dir) === "lib"');
$dir = dirname($dir);
/* Add trailing slash. */
$dir .= '/';
return $dir;
}
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
/**
* This function retrieves a boolean configuration option.
*
* An exception will be thrown if this option isn't a boolean, or if this option isn't found, and no
* default value is given.
*
* @param $name The name of the option.
* @param $default A default value which will be returned if the option isn't found. The option will be
* required if this parameter isn't given. The default value can be any value, including
* NULL.
* @return The option with the given name, or $default if the option isn't found and $default is specified.
*/
public function getBoolean($name, $default = self::REQUIRED_OPTION) {
assert('is_string($name)');
$ret = $this->getValue($name, $default);
if($ret === $default) {
/* The option wasn't found, or it matches the default value. In any case, return
* this value.
*/
return $ret;
}
if(!is_bool($ret)) {
throw new Exception($this->location . ': The option ' . var_export($name, TRUE) .
' is not a valid boolean value.');
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
}
return $ret;
}
/**
* This function retrieves a string configuration option.
*
* An exception will be thrown if this option isn't a string, or if this option isn't found, and no
* default value is given.
*
* @param $name The name of the option.
* @param $default A default value which will be returned if the option isn't found. The option will be
* required if this parameter isn't given. The default value can be any value, including
* NULL.
* @return The option with the given name, or $default if the option isn't found and $default is specified.
*/
public function getString($name, $default = self::REQUIRED_OPTION) {
assert('is_string($name)');
$ret = $this->getValue($name, $default);
if($ret === $default) {
/* The option wasn't found, or it matches the default value. In any case, return
* this value.
*/
return $ret;
}
if(!is_string($ret)) {
throw new Exception($this->location . ': The option ' . var_export($name, TRUE) .
' is not a valid string value.');
}
return $ret;
}
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
/**
* Retrieve a configuration option with one of the given values.
*
* This will check that the configuration option matches one of the given values. The match will use
* strict comparison. An exception will be thrown if it does not match.
*
* The option can be mandatory or optional. If no default value is given, it will be considered to be
* mandatory, and an exception will be thrown if it isn't provided. If a default value is given, it
* is considered to be optional, and the default value is returned. The default value is automatically
* included in the list of allowed values.
*
* @param $name The name of the option.
* @param $allowedValues The values the option is allowed to take, as an array.
* @param $default The default value which will be returned if the option isn't found. If this parameter
* isn't given, the option will be considered to be mandatory. The default value can be
* any value, including NULL.
* @return The option with the given name, or $default if the option isn't found adn $default is given.
*/
public function getValueValidate($name, $allowedValues, $default = self::REQUIRED_OPTION) {
assert('is_string($name)');
assert('is_array($allowedValues)');
$ret = $this->getValue($name, $default);
if($ret === $default) {
/* The option wasn't found, or it matches the default value. In any case, return
* this value.
*/
return $ret;
}
if(!in_array($ret, $allowedValues, TRUE)) {
$strValues = array();
foreach($allowedValues as $av) {
$strValues[] = var_export($av, TRUE);
}
$strValues = implode(', ', $strValues);
throw new Exception($this->location . ': Invalid value given for the option ' .
var_export($name, TRUE) . '. It should have one of the following values: ' .
$strValues . '; but it had the following value: ' . var_export($ret, TRUE));
}
return $ret;
}
Olav Morken
committed
/**
* This function retrieves an array configuration option.
*
* An exception will be thrown if this option isn't an array, or if this option isn't found, and no
* default value is given.
*
* @param string $name The name of the option.
* @param mixed$default A default value which will be returned if the option isn't found. The option will be
* required if this parameter isn't given. The default value can be any value, including
* NULL.
* @return mixed The option with the given name, or $default if the option isn't found and $default is specified.
*/
public function getArray($name, $default = self::REQUIRED_OPTION) {
assert('is_string($name)');
$ret = $this->getValue($name, $default);
if ($ret === $default) {
/* The option wasn't found, or it matches the default value. In any case, return
* this value.
*/
return $ret;
}
if (!is_array($ret)) {
throw new Exception($this->location . ': The option ' . var_export($name, TRUE) .
' is not an array.');
}
return $ret;
}
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
/**
* Retrieve an array as a SimpleSAML_Configuration object.
*
* This function will load the value of an option into a SimpleSAML_Configuration
* object. The option must contain an array.
*
* An exception will be thrown if this option isn't an array, or if this option
* isn't found, and no default value is given.
*
* @param string $name The name of the option.
* @param mixed $default A default value which will be returned if the option isn't found. The option will be
* required if this parameter isn't given. The default value can be any value, including
* NULL.
* @return mixed The option with the given name, or $default if the option isn't found and $default is specified.
*/
public function getConfigItem($name, $default = self::REQUIRED_OPTION) {
assert('is_string($name)');
$ret = $this->getValue($name, $default);
if ($ret === $default) {
/* The option wasn't found, or it matches the default value. In any case, return
* this value.
*/
return $ret;
}
if (!is_array($ret)) {
throw new Exception($this->location . ': The option ' . var_export($name, TRUE) .
' is not an array.');
}
return self::loadFromArray($ret, $this->location . '[' . var_export($name, TRUE) . ']');
}
/**
* Retrieve an array of arrays as an array of SimpleSAML_Configuration objects.
*
* This function will retrieve an option containing an array of arrays, and create an
* array of SimpleSAML_Configuration objects from that array. The indexes in the new
* array will be the same as the original indexes, but the values will be
* SimpleSAML_Configuration objects.
*
* An exception will be thrown if this option isn't an array of arrays, or if this option
* isn't found, and no default value is given.
*
* @param string $name The name of the option.
* @param string $location Name of the items in the array.
* @param mixed $default A default value which will be returned if the option isn't found. The option will be
* required if this parameter isn't given. The default value can be any value, including
* NULL.
* @return mixed The option with the given name, or $default if the option isn't found and $default is specified.
*/
public function getConfigList($name, $default = self::REQUIRED_OPTION) {
assert('is_string($name)');
$ret = $this->getValue($name, $default);
if ($ret === $default) {
/* The option wasn't found, or it matches the default value. In any case, return
* this value.
*/
return $ret;
}
if (!is_array($ret)) {
throw new Exception($this->location . ': The option ' . var_export($name, TRUE) .
' is not an array.');
}
$out = array();
foreach ($ret as $index => $config) {
$newLoc = $this->location . '[' . var_export($name, TRUE) . '][' .
var_export($index, TRUE) . ']';
if (!is_array($config)) {
throw new Exception($newLoc . ': The value of this element was expected to be an array.');
}
$out[$index] = self::loadFromArray($config, $newLoc);
}
return $out;
}
Olav Morken
committed
/**
* Retrieve list of options.
*
* This function returns the name of all options which are defined in this
* configuration file, as an array of strings.
*
* @return array Name of all options defined in this configuration file.
*/
public function getOptions() {
return array_keys($this->configuration);
}