vendor/symfony/dotenv/Dotenv.php line 49

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Dotenv;
  14. use Symfony\Component\Dotenv\Exception\FormatException;
  15. use Symfony\Component\Dotenv\Exception\FormatExceptionContext;
  16. use Symfony\Component\Dotenv\Exception\PathException;
  17. use Symfony\Component\Process\Exception\ExceptionInterface as ProcessException;
  18. use Symfony\Component\Process\Process;
  20. /**
  21.  * Manages .env files.
  22.  *
  23.  * @author Fabien Potencier <fabien@symfony.com>
  24.  * @author Kévin Dunglas <dunglas@gmail.com>
  25.  */
  26. final class Dotenv
  27. {
  28.     public const VARNAME_REGEX = '(?i:_?[A-Z][A-Z0-9_]*+)';
  29.     public const STATE_VARNAME = 0;
  30.     public const STATE_VALUE = 1;
  32.     private $path;
  33.     private $cursor;
  34.     private $lineno;
  35.     private $data;
  36.     private $end;
  37.     private $values;
  38.     private $envKey;
  39.     private $debugKey;
  40.     private $prodEnvs = ['prod'];
  41.     private $usePutenv = false;
  43.     /**
  44.      * @param string $envKey
  45.      */
  46.     public function __construct($envKey = 'APP_ENV', string $debugKey = 'APP_DEBUG')
  47.     {
  48.         if (\in_array($envKey = (string) $envKey, ['1', ''], true)) {
  49.             trigger_deprecation('symfony/dotenv', '5.1', 'Passing a boolean to the constructor of "%s" is deprecated, use "Dotenv::usePutenv()".', __CLASS__);
  50.             $this->usePutenv = (bool) $envKey;
  51.             $envKey = 'APP_ENV';
  52.         }
  54.         $this->envKey = $envKey;
  55.         $this->debugKey = $debugKey;
  56.     }
  58.     /**
  59.      * @return $this
  60.      */
  61.     public function setProdEnvs(array $prodEnvs): self
  62.     {
  63.         $this->prodEnvs = $prodEnvs;
  65.         return $this;
  66.     }
  68.     /**
  69.      * @param bool $usePutenv If `putenv()` should be used to define environment variables or not.
  70.      *                        Beware that `putenv()` is not thread safe, that's why it's not enabled by default
  71.      *
  72.      * @return $this
  73.      */
  74.     public function usePutenv(bool $usePutenv = true): self
  75.     {
  76.         $this->usePutenv = $usePutenv;
  78.         return $this;
  79.     }
  81.     /**
  82.      * Loads one or several .env files.
  83.      *
  84.      * @param string $path          A file to load
  85.      * @param string ...$extraPaths A list of additional files to load
  86.      *
  87.      * @throws FormatException when a file has a syntax error
  88.      * @throws PathException   when a file does not exist or is not readable
  89.      */
  90.     public function load(string $path, string ...$extraPaths): void
  91.     {
  92.         $this->doLoad(false, \func_get_args());
  93.     }
  95.     /**
  96.      * Loads a .env file and the corresponding .env.local, .env.$env and .env.$env.local files if they exist.
  97.      *
  98.      * .env.local is always ignored in test env because tests should produce the same results for everyone.
  99.      * .env.dist is loaded when it exists and .env is not found.
  100.      *
  101.      * @param string      $path                 A file to load
  102.      * @param string|null $envKey               The name of the env vars that defines the app env
  103.      * @param string      $defaultEnv           The app env to use when none is defined
  104.      * @param array       $testEnvs             A list of app envs for which .env.local should be ignored
  105.      * @param bool        $overrideExistingVars Whether existing environment variables set by the system should be overridden
  106.      *
  107.      * @throws FormatException when a file has a syntax error
  108.      * @throws PathException   when a file does not exist or is not readable
  109.      */
  110.     public function loadEnv(string $path, ?string $envKey = null, string $defaultEnv = 'dev', array $testEnvs = ['test'], bool $overrideExistingVars = false): void
  111.     {
  112.         $k = $envKey ?? $this->envKey;
  114.         if (is_file($path) || !is_file($p = "$path.dist")) {
  115.             $this->doLoad($overrideExistingVars, [$path]);
  116.         } else {
  117.             $this->doLoad($overrideExistingVars, [$p]);
  118.         }
  120.         if (null === $env = $_SERVER[$k] ?? $_ENV[$k] ?? null) {
  121.             $this->populate([$k => $env = $defaultEnv], $overrideExistingVars);
  122.         }
  124.         if (!\in_array($env, $testEnvs, true) && is_file($p = "$path.local")) {
  125.             $this->doLoad($overrideExistingVars, [$p]);
  126.             $env = $_SERVER[$k] ?? $_ENV[$k] ?? $env;
  127.         }
  129.         if ('local' === $env) {
  130.             return;
  131.         }
  133.         if (is_file($p = "$path.$env")) {
  134.             $this->doLoad($overrideExistingVars, [$p]);
  135.         }
  137.         if (is_file($p = "$path.$env.local")) {
  138.             $this->doLoad($overrideExistingVars, [$p]);
  139.         }
  140.     }
  142.     /**
  143.      * Loads env vars from .env.local.php if the file exists or from the other .env files otherwise.
  144.      *
  145.      * This method also configures the APP_DEBUG env var according to the current APP_ENV.
  146.      *
  147.      * See method loadEnv() for rules related to .env files.
  148.      */
  149.     public function bootEnv(string $path, string $defaultEnv = 'dev', array $testEnvs = ['test'], bool $overrideExistingVars = false): void
  150.     {
  151.         $p = $path.'.local.php';
  152.         $env = is_file($p) ? include $p : null;
  153.         $k = $this->envKey;
  155.         if (\is_array($env) && ($overrideExistingVars || !isset($env[$k]) || ($_SERVER[$k] ?? $_ENV[$k] ?? $env[$k]) === $env[$k])) {
  156.             $this->populate($env, $overrideExistingVars);
  157.         } else {
  158.             $this->loadEnv($path, $k, $defaultEnv, $testEnvs, $overrideExistingVars);
  159.         }
  161.         $_SERVER += $_ENV;
  163.         $k = $this->debugKey;
  164.         $debug = $_SERVER[$k] ?? !\in_array($_SERVER[$this->envKey], $this->prodEnvs, true);
  165.         $_SERVER[$k] = $_ENV[$k] = (int) $debug || (!\is_bool($debug) && filter_var($debug, \FILTER_VALIDATE_BOOLEAN)) ? '1' : '0';
  166.     }
  168.     /**
  169.      * Loads one or several .env files and enables override existing vars.
  170.      *
  171.      * @param string $path          A file to load
  172.      * @param string ...$extraPaths A list of additional files to load
  173.      *
  174.      * @throws FormatException when a file has a syntax error
  175.      * @throws PathException   when a file does not exist or is not readable
  176.      */
  177.     public function overload(string $path, string ...$extraPaths): void
  178.     {
  179.         $this->doLoad(true, \func_get_args());
  180.     }
  182.     /**
  183.      * Sets values as environment variables (via putenv, $_ENV, and $_SERVER).
  184.      *
  185.      * @param array $values               An array of env variables
  186.      * @param bool  $overrideExistingVars Whether existing environment variables set by the system should be overridden
  187.      */
  188.     public function populate(array $values, bool $overrideExistingVars = false): void
  189.     {
  190.         $updateLoadedVars = false;
  191.         $loadedVars = array_flip(explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? ''));
  193.         foreach ($values as $name => $value) {
  194.             $notHttpName = 0 !== strpos($name, 'HTTP_');
  195.             if (isset($_SERVER[$name]) && $notHttpName && !isset($_ENV[$name])) {
  196.                 $_ENV[$name] = $_SERVER[$name];
  197.             }
  199.             // don't check existence with getenv() because of thread safety issues
  200.             if (!isset($loadedVars[$name]) && !$overrideExistingVars && isset($_ENV[$name])) {
  201.                 continue;
  202.             }
  204.             if ($this->usePutenv) {
  205.                 putenv("$name=$value");
  206.             }
  208.             $_ENV[$name] = $value;
  209.             if ($notHttpName) {
  210.                 $_SERVER[$name] = $value;
  211.             }
  213.             if (!isset($loadedVars[$name])) {
  214.                 $loadedVars[$name] = $updateLoadedVars = true;
  215.             }
  216.         }
  218.         if ($updateLoadedVars) {
  219.             unset($loadedVars['']);
  220.             $loadedVars = implode(',', array_keys($loadedVars));
  221.             $_ENV['SYMFONY_DOTENV_VARS'] = $_SERVER['SYMFONY_DOTENV_VARS'] = $loadedVars;
  223.             if ($this->usePutenv) {
  224.                 putenv('SYMFONY_DOTENV_VARS='.$loadedVars);
  225.             }
  226.         }
  227.     }
  229.     /**
  230.      * Parses the contents of an .env file.
  231.      *
  232.      * @param string $data The data to be parsed
  233.      * @param string $path The original file name where data where stored (used for more meaningful error messages)
  234.      *
  235.      * @throws FormatException when a file has a syntax error
  236.      */
  237.     public function parse(string $data, string $path = '.env'): array
  238.     {
  239.         $this->path = $path;
  240.         $this->data = str_replace(["\r\n", "\r"], "\n", $data);
  241.         $this->lineno = 1;
  242.         $this->cursor = 0;
  243.         $this->end = \strlen($this->data);
  244.         $state = self::STATE_VARNAME;
  245.         $this->values = [];
  246.         $name = '';
  248.         $this->skipEmptyLines();
  250.         while ($this->cursor < $this->end) {
  251.             switch ($state) {
  252.                 case self::STATE_VARNAME:
  253.                     $name = $this->lexVarname();
  254.                     $state = self::STATE_VALUE;
  255.                     break;
  257.                 case self::STATE_VALUE:
  258.                     $this->values[$name] = $this->lexValue();
  259.                     $state = self::STATE_VARNAME;
  260.                     break;
  261.             }
  262.         }
  264.         if (self::STATE_VALUE === $state) {
  265.             $this->values[$name] = '';
  266.         }
  268.         try {
  269.             return $this->values;
  270.         } finally {
  271.             $this->values = [];
  272.             $this->data = null;
  273.             $this->path = null;
  274.         }
  275.     }
  277.     private function lexVarname(): string
  278.     {
  279.         // var name + optional export
  280.         if (!preg_match('/(export[ \t]++)?('.self::VARNAME_REGEX.')/A', $this->data, $matches, 0, $this->cursor)) {
  281.             throw $this->createFormatException('Invalid character in variable name');
  282.         }
  283.         $this->moveCursor($matches[0]);
  285.         if ($this->cursor === $this->end || "\n" === $this->data[$this->cursor] || '#' === $this->data[$this->cursor]) {
  286.             if ($matches[1]) {
  287.                 throw $this->createFormatException('Unable to unset an environment variable');
  288.             }
  290.             throw $this->createFormatException('Missing = in the environment variable declaration');
  291.         }
  293.         if (' ' === $this->data[$this->cursor] || "\t" === $this->data[$this->cursor]) {
  294.             throw $this->createFormatException('Whitespace characters are not supported after the variable name');
  295.         }
  297.         if ('=' !== $this->data[$this->cursor]) {
  298.             throw $this->createFormatException('Missing = in the environment variable declaration');
  299.         }
  300.         ++$this->cursor;
  302.         return $matches[2];
  303.     }
  305.     private function lexValue(): string
  306.     {
  307.         if (preg_match('/[ \t]*+(?:#.*)?$/Am', $this->data, $matches, 0, $this->cursor)) {
  308.             $this->moveCursor($matches[0]);
  309.             $this->skipEmptyLines();
  311.             return '';
  312.         }
  314.         if (' ' === $this->data[$this->cursor] || "\t" === $this->data[$this->cursor]) {
  315.             throw $this->createFormatException('Whitespace are not supported before the value');
  316.         }
  318.         $loadedVars = array_flip(explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? ($_ENV['SYMFONY_DOTENV_VARS'] ?? '')));
  319.         unset($loadedVars['']);
  320.         $v = '';
  322.         do {
  323.             if ("'" === $this->data[$this->cursor]) {
  324.                 $len = 0;
  326.                 do {
  327.                     if ($this->cursor + ++$len === $this->end) {
  328.                         $this->cursor += $len;
  330.                         throw $this->createFormatException('Missing quote to end the value');
  331.                     }
  332.                 } while ("'" !== $this->data[$this->cursor + $len]);
  334.                 $v .= substr($this->data, 1 + $this->cursor, $len - 1);
  335.                 $this->cursor += 1 + $len;
  336.             } elseif ('"' === $this->data[$this->cursor]) {
  337.                 $value = '';
  339.                 if (++$this->cursor === $this->end) {
  340.                     throw $this->createFormatException('Missing quote to end the value');
  341.                 }
  343.                 while ('"' !== $this->data[$this->cursor] || ('\\' === $this->data[$this->cursor - 1] && '\\' !== $this->data[$this->cursor - 2])) {
  344.                     $value .= $this->data[$this->cursor];
  345.                     ++$this->cursor;
  347.                     if ($this->cursor === $this->end) {
  348.                         throw $this->createFormatException('Missing quote to end the value');
  349.                     }
  350.                 }
  351.                 ++$this->cursor;
  352.                 $value = str_replace(['\\"', '\r', '\n'], ['"', "\r", "\n"], $value);
  353.                 $resolvedValue = $value;
  354.                 $resolvedValue = $this->resolveCommands($resolvedValue, $loadedVars);
  355.                 $resolvedValue = $this->resolveVariables($resolvedValue, $loadedVars);
  356.                 $resolvedValue = str_replace('\\\\', '\\', $resolvedValue);
  357.                 $v .= $resolvedValue;
  358.             } else {
  359.                 $value = '';
  360.                 $prevChr = $this->data[$this->cursor - 1];
  361.                 while ($this->cursor < $this->end && !\in_array($this->data[$this->cursor], ["\n", '"', "'"], true) && !((' ' === $prevChr || "\t" === $prevChr) && '#' === $this->data[$this->cursor])) {
  362.                     if ('\\' === $this->data[$this->cursor] && isset($this->data[$this->cursor + 1]) && ('"' === $this->data[$this->cursor + 1] || "'" === $this->data[$this->cursor + 1])) {
  363.                         ++$this->cursor;
  364.                     }
  366.                     $value .= $prevChr = $this->data[$this->cursor];
  368.                     if ('$' === $this->data[$this->cursor] && isset($this->data[$this->cursor + 1]) && '(' === $this->data[$this->cursor + 1]) {
  369.                         ++$this->cursor;
  370.                         $value .= '('.$this->lexNestedExpression().')';
  371.                     }
  373.                     ++$this->cursor;
  374.                 }
  375.                 $value = rtrim($value);
  376.                 $resolvedValue = $value;
  377.                 $resolvedValue = $this->resolveCommands($resolvedValue, $loadedVars);
  378.                 $resolvedValue = $this->resolveVariables($resolvedValue, $loadedVars);
  379.                 $resolvedValue = str_replace('\\\\', '\\', $resolvedValue);
  381.                 if ($resolvedValue === $value && preg_match('/\s+/', $value)) {
  382.                     throw $this->createFormatException('A value containing spaces must be surrounded by quotes');
  383.                 }
  385.                 $v .= $resolvedValue;
  387.                 if ($this->cursor < $this->end && '#' === $this->data[$this->cursor]) {
  388.                     break;
  389.                 }
  390.             }
  391.         } while ($this->cursor < $this->end && "\n" !== $this->data[$this->cursor]);
  393.         $this->skipEmptyLines();
  395.         return $v;
  396.     }
  398.     private function lexNestedExpression(): string
  399.     {
  400.         ++$this->cursor;
  401.         $value = '';
  403.         while ("\n" !== $this->data[$this->cursor] && ')' !== $this->data[$this->cursor]) {
  404.             $value .= $this->data[$this->cursor];
  406.             if ('(' === $this->data[$this->cursor]) {
  407.                 $value .= $this->lexNestedExpression().')';
  408.             }
  410.             ++$this->cursor;
  412.             if ($this->cursor === $this->end) {
  413.                 throw $this->createFormatException('Missing closing parenthesis.');
  414.             }
  415.         }
  417.         if ("\n" === $this->data[$this->cursor]) {
  418.             throw $this->createFormatException('Missing closing parenthesis.');
  419.         }
  421.         return $value;
  422.     }
  424.     private function skipEmptyLines()
  425.     {
  426.         if (preg_match('/(?:\s*+(?:#[^\n]*+)?+)++/A', $this->data, $match, 0, $this->cursor)) {
  427.             $this->moveCursor($match[0]);
  428.         }
  429.     }
  431.     private function resolveCommands(string $value, array $loadedVars): string
  432.     {
  433.         if (false === strpos($value, '$')) {
  434.             return $value;
  435.         }
  437.         $regex = '/
  438.             (\\\\)?               # escaped with a backslash?
  439.             \$
  440.             (?<cmd>
  441.                 \(                # require opening parenthesis
  442.                 ([^()]|\g<cmd>)+  # allow any number of non-parens, or balanced parens (by nesting the <cmd> expression recursively)
  443.                 \)                # require closing paren
  444.             )
  445.         /x';
  447.         return preg_replace_callback($regex, function ($matches) use ($loadedVars) {
  448.             if ('\\' === $matches[1]) {
  449.                 return substr($matches[0], 1);
  450.             }
  452.             if ('\\' === \DIRECTORY_SEPARATOR) {
  453.                 throw new \LogicException('Resolving commands is not supported on Windows.');
  454.             }
  456.             if (!class_exists(Process::class)) {
  457.                 throw new \LogicException('Resolving commands requires the Symfony Process component.');
  458.             }
  460.             $process = method_exists(Process::class, 'fromShellCommandline') ? Process::fromShellCommandline('echo '.$matches[0]) : new Process('echo '.$matches[0]);
  462.             if (!method_exists(Process::class, 'fromShellCommandline') && method_exists(Process::class, 'inheritEnvironmentVariables')) {
  463.                 // Symfony 3.4 does not inherit env vars by default:
  464.                 $process->inheritEnvironmentVariables();
  465.             }
  467.             $env = [];
  468.             foreach ($this->values as $name => $value) {
  469.                 if (isset($loadedVars[$name]) || (!isset($_ENV[$name]) && !(isset($_SERVER[$name]) && 0 !== strpos($name, 'HTTP_')))) {
  470.                     $env[$name] = $value;
  471.                 }
  472.             }
  473.             $process->setEnv($env);
  475.             try {
  476.                 $process->mustRun();
  477.             } catch (ProcessException $e) {
  478.                 throw $this->createFormatException(sprintf('Issue expanding a command (%s)', $process->getErrorOutput()));
  479.             }
  481.             return preg_replace('/[\r\n]+$/', '', $process->getOutput());
  482.         }, $value);
  483.     }
  485.     private function resolveVariables(string $value, array $loadedVars): string
  486.     {
  487.         if (false === strpos($value, '$')) {
  488.             return $value;
  489.         }
  491.         $regex = '/
  492.             (?<!\\\\)
  493.             (?P<backslashes>\\\\*)             # escaped with a backslash?
  494.             \$
  495.             (?!\()                             # no opening parenthesis
  496.             (?P<opening_brace>\{)?             # optional brace
  497.             (?P<name>'.self::VARNAME_REGEX.')? # var name
  498.             (?P<default_value>:[-=][^\}]*+)?   # optional default value
  499.             (?P<closing_brace>\})?             # optional closing brace
  500.         /x';
  502.         $value = preg_replace_callback($regex, function ($matches) use ($loadedVars) {
  503.             // odd number of backslashes means the $ character is escaped
  504.             if (1 === \strlen($matches['backslashes']) % 2) {
  505.                 return substr($matches[0], 1);
  506.             }
  508.             // unescaped $ not followed by variable name
  509.             if (!isset($matches['name'])) {
  510.                 return $matches[0];
  511.             }
  513.             if ('{' === $matches['opening_brace'] && !isset($matches['closing_brace'])) {
  514.                 throw $this->createFormatException('Unclosed braces on variable expansion');
  515.             }
  517.             $name = $matches['name'];
  518.             if (isset($loadedVars[$name]) && isset($this->values[$name])) {
  519.                 $value = $this->values[$name];
  520.             } elseif (isset($_ENV[$name])) {
  521.                 $value = $_ENV[$name];
  522.             } elseif (isset($_SERVER[$name]) && 0 !== strpos($name, 'HTTP_')) {
  523.                 $value = $_SERVER[$name];
  524.             } elseif (isset($this->values[$name])) {
  525.                 $value = $this->values[$name];
  526.             } else {
  527.                 $value = (string) getenv($name);
  528.             }
  530.             if ('' === $value && isset($matches['default_value']) && '' !== $matches['default_value']) {
  531.                 $unsupportedChars = strpbrk($matches['default_value'], '\'"{$');
  532.                 if (false !== $unsupportedChars) {
  533.                     throw $this->createFormatException(sprintf('Unsupported character "%s" found in the default value of variable "$%s".', $unsupportedChars[0], $name));
  534.                 }
  536.                 $value = substr($matches['default_value'], 2);
  538.                 if ('=' === $matches['default_value'][1]) {
  539.                     $this->values[$name] = $value;
  540.                 }
  541.             }
  543.             if (!$matches['opening_brace'] && isset($matches['closing_brace'])) {
  544.                 $value .= '}';
  545.             }
  547.             return $matches['backslashes'].$value;
  548.         }, $value);
  550.         return $value;
  551.     }
  553.     private function moveCursor(string $text)
  554.     {
  555.         $this->cursor += \strlen($text);
  556.         $this->lineno += substr_count($text, "\n");
  557.     }
  559.     private function createFormatException(string $message): FormatException
  560.     {
  561.         return new FormatException($message, new FormatExceptionContext($this->data, $this->path, $this->lineno, $this->cursor));
  562.     }
  564.     private function doLoad(bool $overrideExistingVars, array $paths): void
  565.     {
  566.         foreach ($paths as $path) {
  567.             if (!is_readable($path) || is_dir($path)) {
  568.                 throw new PathException($path);
  569.             }
  571.             $data = file_get_contents($path);
  573.             if ("\xEF\xBB\xBF" === substr($data, 0, 3)) {
  574.                 throw new FormatException('Loading files starting with a byte-order-mark (BOM) is not supported.', new FormatExceptionContext($data, $path, 1, 0));
  575.             }
  577.             $this->populate($this->parse($data, $path), $overrideExistingVars);
  578.         }
  579.     }
  580. }