vendor/symfony/dotenv/Dotenv.php line 48

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 $usePutenv;
  40.     /**
  41.      * @var bool If `putenv()` should be used to define environment variables or not.
  42.      *           Beware that `putenv()` is not thread safe and this setting will default
  43.      *           to `false` in Symfony 5.0.
  44.      */
  45.     public function __construct(bool $usePutenv = true)
  46.     {
  47.         if (!\func_num_args()) {
  48.             @trigger_error(sprintf('The default value of "$usePutenv" argument of "%s" will be changed from "true" to "false" in Symfony 5.0. You should define its value explicitly.', __METHOD__), \E_USER_DEPRECATED);
  49.         }
  51.         $this->usePutenv = $usePutenv;
  52.     }
  54.     /**
  55.      * Loads one or several .env files.
  56.      *
  57.      * @param string   $path          A file to load
  58.      * @param string[] ...$extraPaths A list of additional files to load
  59.      *
  60.      * @throws FormatException when a file has a syntax error
  61.      * @throws PathException   when a file does not exist or is not readable
  62.      */
  63.     public function load(string $path, string ...$extraPaths): void
  64.     {
  65.         $this->doLoad(false, \func_get_args());
  66.     }
  68.     /**
  69.      * Loads a .env file and the corresponding .env.local, .env.$env and .env.$env.local files if they exist.
  70.      *
  71.      * .env.local is always ignored in test env because tests should produce the same results for everyone.
  72.      * .env.dist is loaded when it exists and .env is not found.
  73.      *
  74.      * @param string $path       A file to load
  75.      * @param string $varName    The name of the env vars that defines the app env
  76.      * @param string $defaultEnv The app env to use when none is defined
  77.      * @param array  $testEnvs   A list of app envs for which .env.local should be ignored
  78.      *
  79.      * @throws FormatException when a file has a syntax error
  80.      * @throws PathException   when a file does not exist or is not readable
  81.      */
  82.     public function loadEnv(string $path, string $varName = 'APP_ENV', string $defaultEnv = 'dev', array $testEnvs = ['test']): void
  83.     {
  84.         if (file_exists($path) || !file_exists($p = "$path.dist")) {
  85.             $this->load($path);
  86.         } else {
  87.             $this->load($p);
  88.         }
  90.         if (null === $env = $_SERVER[$varName] ?? $_ENV[$varName] ?? null) {
  91.             $this->populate([$varName => $env = $defaultEnv]);
  92.         }
  94.         if (!\in_array($env, $testEnvs, true) && file_exists($p = "$path.local")) {
  95.             $this->load($p);
  96.             $env = $_SERVER[$varName] ?? $_ENV[$varName] ?? $env;
  97.         }
  99.         if ('local' === $env) {
  100.             return;
  101.         }
  103.         if (file_exists($p = "$path.$env")) {
  104.             $this->load($p);
  105.         }
  107.         if (file_exists($p = "$path.$env.local")) {
  108.             $this->load($p);
  109.         }
  110.     }
  112.     /**
  113.      * Loads one or several .env files and enables override existing vars.
  114.      *
  115.      * @param string   $path          A file to load
  116.      * @param string[] ...$extraPaths A list of additional files to load
  117.      *
  118.      * @throws FormatException when a file has a syntax error
  119.      * @throws PathException   when a file does not exist or is not readable
  120.      */
  121.     public function overload(string $path, string ...$extraPaths): void
  122.     {
  123.         $this->doLoad(true, \func_get_args());
  124.     }
  126.     /**
  127.      * Sets values as environment variables (via putenv, $_ENV, and $_SERVER).
  128.      *
  129.      * @param array $values               An array of env variables
  130.      * @param bool  $overrideExistingVars true when existing environment variables must be overridden
  131.      */
  132.     public function populate(array $values, bool $overrideExistingVars = false): void
  133.     {
  134.         $updateLoadedVars = false;
  135.         $loadedVars = array_flip(explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? ''));
  137.         foreach ($values as $name => $value) {
  138.             $notHttpName = 0 !== strpos($name, 'HTTP_');
  139.             if (isset($_SERVER[$name]) && $notHttpName && !isset($_ENV[$name])) {
  140.                 $_ENV[$name] = $_SERVER[$name];
  141.             }
  143.             // don't check existence with getenv() because of thread safety issues
  144.             if (!isset($loadedVars[$name]) && !$overrideExistingVars && isset($_ENV[$name])) {
  145.                 continue;
  146.             }
  148.             if ($this->usePutenv) {
  149.                 putenv("$name=$value");
  150.             }
  152.             $_ENV[$name] = $value;
  153.             if ($notHttpName) {
  154.                 $_SERVER[$name] = $value;
  155.             }
  157.             if (!isset($loadedVars[$name])) {
  158.                 $loadedVars[$name] = $updateLoadedVars = true;
  159.             }
  160.         }
  162.         if ($updateLoadedVars) {
  163.             unset($loadedVars['']);
  164.             $loadedVars = implode(',', array_keys($loadedVars));
  165.             $_ENV['SYMFONY_DOTENV_VARS'] = $_SERVER['SYMFONY_DOTENV_VARS'] = $loadedVars;
  167.             if ($this->usePutenv) {
  168.                 putenv('SYMFONY_DOTENV_VARS='.$loadedVars);
  169.             }
  170.         }
  171.     }
  173.     /**
  174.      * Parses the contents of an .env file.
  175.      *
  176.      * @param string $data The data to be parsed
  177.      * @param string $path The original file name where data where stored (used for more meaningful error messages)
  178.      *
  179.      * @return array An array of env variables
  180.      *
  181.      * @throws FormatException when a file has a syntax error
  182.      */
  183.     public function parse(string $data, string $path = '.env'): array
  184.     {
  185.         $this->path = $path;
  186.         $this->data = str_replace(["\r\n", "\r"], "\n", $data);
  187.         $this->lineno = 1;
  188.         $this->cursor = 0;
  189.         $this->end = \strlen($this->data);
  190.         $state = self::STATE_VARNAME;
  191.         $this->values = [];
  192.         $name = '';
  194.         $this->skipEmptyLines();
  196.         while ($this->cursor < $this->end) {
  197.             switch ($state) {
  198.                 case self::STATE_VARNAME:
  199.                     $name = $this->lexVarname();
  200.                     $state = self::STATE_VALUE;
  201.                     break;
  203.                 case self::STATE_VALUE:
  204.                     $this->values[$name] = $this->lexValue();
  205.                     $state = self::STATE_VARNAME;
  206.                     break;
  207.             }
  208.         }
  210.         if (self::STATE_VALUE === $state) {
  211.             $this->values[$name] = '';
  212.         }
  214.         try {
  215.             return $this->values;
  216.         } finally {
  217.             $this->values = [];
  218.             $this->data = null;
  219.             $this->path = null;
  220.         }
  221.     }
  223.     private function lexVarname(): string
  224.     {
  225.         // var name + optional export
  226.         if (!preg_match('/(export[ \t]++)?('.self::VARNAME_REGEX.')/A', $this->data, $matches, 0, $this->cursor)) {
  227.             throw $this->createFormatException('Invalid character in variable name');
  228.         }
  229.         $this->moveCursor($matches[0]);
  231.         if ($this->cursor === $this->end || "\n" === $this->data[$this->cursor] || '#' === $this->data[$this->cursor]) {
  232.             if ($matches[1]) {
  233.                 throw $this->createFormatException('Unable to unset an environment variable');
  234.             }
  236.             throw $this->createFormatException('Missing = in the environment variable declaration');
  237.         }
  239.         if (' ' === $this->data[$this->cursor] || "\t" === $this->data[$this->cursor]) {
  240.             throw $this->createFormatException('Whitespace characters are not supported after the variable name');
  241.         }
  243.         if ('=' !== $this->data[$this->cursor]) {
  244.             throw $this->createFormatException('Missing = in the environment variable declaration');
  245.         }
  246.         ++$this->cursor;
  248.         return $matches[2];
  249.     }
  251.     private function lexValue(): string
  252.     {
  253.         if (preg_match('/[ \t]*+(?:#.*)?$/Am', $this->data, $matches, 0, $this->cursor)) {
  254.             $this->moveCursor($matches[0]);
  255.             $this->skipEmptyLines();
  257.             return '';
  258.         }
  260.         if (' ' === $this->data[$this->cursor] || "\t" === $this->data[$this->cursor]) {
  261.             throw $this->createFormatException('Whitespace are not supported before the value');
  262.         }
  264.         $loadedVars = array_flip(explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? ($_ENV['SYMFONY_DOTENV_VARS'] ?? '')));
  265.         unset($loadedVars['']);
  266.         $v = '';
  268.         do {
  269.             if ("'" === $this->data[$this->cursor]) {
  270.                 $len = 0;
  272.                 do {
  273.                     if ($this->cursor + ++$len === $this->end) {
  274.                         $this->cursor += $len;
  276.                         throw $this->createFormatException('Missing quote to end the value');
  277.                     }
  278.                 } while ("'" !== $this->data[$this->cursor + $len]);
  280.                 $v .= substr($this->data, 1 + $this->cursor, $len - 1);
  281.                 $this->cursor += 1 + $len;
  282.             } elseif ('"' === $this->data[$this->cursor]) {
  283.                 $value = '';
  285.                 if (++$this->cursor === $this->end) {
  286.                     throw $this->createFormatException('Missing quote to end the value');
  287.                 }
  289.                 while ('"' !== $this->data[$this->cursor] || ('\\' === $this->data[$this->cursor - 1] && '\\' !== $this->data[$this->cursor - 2])) {
  290.                     $value .= $this->data[$this->cursor];
  291.                     ++$this->cursor;
  293.                     if ($this->cursor === $this->end) {
  294.                         throw $this->createFormatException('Missing quote to end the value');
  295.                     }
  296.                 }
  297.                 ++$this->cursor;
  298.                 $value = str_replace(['\\"', '\r', '\n'], ['"', "\r", "\n"], $value);
  299.                 $resolvedValue = $value;
  300.                 $resolvedValue = $this->resolveVariables($resolvedValue, $loadedVars);
  301.                 $resolvedValue = $this->resolveCommands($resolvedValue, $loadedVars);
  302.                 $resolvedValue = str_replace('\\\\', '\\', $resolvedValue);
  303.                 $v .= $resolvedValue;
  304.             } else {
  305.                 $value = '';
  306.                 $prevChr = $this->data[$this->cursor - 1];
  307.                 while ($this->cursor < $this->end && !\in_array($this->data[$this->cursor], ["\n", '"', "'"], true) && !((' ' === $prevChr || "\t" === $prevChr) && '#' === $this->data[$this->cursor])) {
  308.                     if ('\\' === $this->data[$this->cursor] && isset($this->data[$this->cursor + 1]) && ('"' === $this->data[$this->cursor + 1] || "'" === $this->data[$this->cursor + 1])) {
  309.                         ++$this->cursor;
  310.                     }
  312.                     $value .= $prevChr = $this->data[$this->cursor];
  314.                     if ('$' === $this->data[$this->cursor] && isset($this->data[$this->cursor + 1]) && '(' === $this->data[$this->cursor + 1]) {
  315.                         ++$this->cursor;
  316.                         $value .= '('.$this->lexNestedExpression().')';
  317.                     }
  319.                     ++$this->cursor;
  320.                 }
  321.                 $value = rtrim($value);
  322.                 $resolvedValue = $value;
  323.                 $resolvedValue = $this->resolveVariables($resolvedValue, $loadedVars);
  324.                 $resolvedValue = $this->resolveCommands($resolvedValue, $loadedVars);
  325.                 $resolvedValue = str_replace('\\\\', '\\', $resolvedValue);
  327.                 if ($resolvedValue === $value && preg_match('/\s+/', $value)) {
  328.                     throw $this->createFormatException('A value containing spaces must be surrounded by quotes');
  329.                 }
  331.                 $v .= $resolvedValue;
  333.                 if ($this->cursor < $this->end && '#' === $this->data[$this->cursor]) {
  334.                     break;
  335.                 }
  336.             }
  337.         } while ($this->cursor < $this->end && "\n" !== $this->data[$this->cursor]);
  339.         $this->skipEmptyLines();
  341.         return $v;
  342.     }
  344.     private function lexNestedExpression(): string
  345.     {
  346.         ++$this->cursor;
  347.         $value = '';
  349.         while ("\n" !== $this->data[$this->cursor] && ')' !== $this->data[$this->cursor]) {
  350.             $value .= $this->data[$this->cursor];
  352.             if ('(' === $this->data[$this->cursor]) {
  353.                 $value .= $this->lexNestedExpression().')';
  354.             }
  356.             ++$this->cursor;
  358.             if ($this->cursor === $this->end) {
  359.                 throw $this->createFormatException('Missing closing parenthesis.');
  360.             }
  361.         }
  363.         if ("\n" === $this->data[$this->cursor]) {
  364.             throw $this->createFormatException('Missing closing parenthesis.');
  365.         }
  367.         return $value;
  368.     }
  370.     private function skipEmptyLines()
  371.     {
  372.         if (preg_match('/(?:\s*+(?:#[^\n]*+)?+)++/A', $this->data, $match, 0, $this->cursor)) {
  373.             $this->moveCursor($match[0]);
  374.         }
  375.     }
  377.     private function resolveCommands(string $value, array $loadedVars): string
  378.     {
  379.         if (false === strpos($value, '$')) {
  380.             return $value;
  381.         }
  383.         $regex = '/
  384.             (\\\\)?               # escaped with a backslash?
  385.             \$
  386.             (?<cmd>
  387.                 \(                # require opening parenthesis
  388.                 ([^()]|\g<cmd>)+  # allow any number of non-parens, or balanced parens (by nesting the <cmd> expression recursively)
  389.                 \)                # require closing paren
  390.             )
  391.         /x';
  393.         return preg_replace_callback($regex, function ($matches) use ($loadedVars) {
  394.             if ('\\' === $matches[1]) {
  395.                 return substr($matches[0], 1);
  396.             }
  398.             if ('\\' === \DIRECTORY_SEPARATOR) {
  399.                 throw new \LogicException('Resolving commands is not supported on Windows.');
  400.             }
  402.             if (!class_exists(Process::class)) {
  403.                 throw new \LogicException('Resolving commands requires the Symfony Process component.');
  404.             }
  406.             $process = method_exists(Process::class, 'fromShellCommandline') ? Process::fromShellCommandline('echo '.$matches[0]) : new Process('echo '.$matches[0]);
  408.             if (!method_exists(Process::class, 'fromShellCommandline') && method_exists(Process::class, 'inheritEnvironmentVariables')) {
  409.                 // Symfony 3.4 does not inherit env vars by default:
  410.                 $process->inheritEnvironmentVariables();
  411.             }
  413.             $env = [];
  414.             foreach ($this->values as $name => $value) {
  415.                 if (isset($loadedVars[$name]) || (!isset($_ENV[$name]) && !(isset($_SERVER[$name]) && 0 !== strpos($name, 'HTTP_')))) {
  416.                     $env[$name] = $value;
  417.                 }
  418.             }
  419.             $process->setEnv($env);
  421.             try {
  422.                 $process->mustRun();
  423.             } catch (ProcessException $e) {
  424.                 throw $this->createFormatException(sprintf('Issue expanding a command (%s)', $process->getErrorOutput()));
  425.             }
  427.             return preg_replace('/[\r\n]+$/', '', $process->getOutput());
  428.         }, $value);
  429.     }
  431.     private function resolveVariables(string $value, array $loadedVars): string
  432.     {
  433.         if (false === strpos($value, '$')) {
  434.             return $value;
  435.         }
  437.         $regex = '/
  438.             (?<!\\\\)
  439.             (?P<backslashes>\\\\*)             # escaped with a backslash?
  440.             \$
  441.             (?!\()                             # no opening parenthesis
  442.             (?P<opening_brace>\{)?             # optional brace
  443.             (?P<name>'.self::VARNAME_REGEX.')? # var name
  444.             (?P<default_value>:[-=][^\}]++)?   # optional default value
  445.             (?P<closing_brace>\})?             # optional closing brace
  446.         /x';
  448.         $value = preg_replace_callback($regex, function ($matches) use ($loadedVars) {
  449.             // odd number of backslashes means the $ character is escaped
  450.             if (1 === \strlen($matches['backslashes']) % 2) {
  451.                 return substr($matches[0], 1);
  452.             }
  454.             // unescaped $ not followed by variable name
  455.             if (!isset($matches['name'])) {
  456.                 return $matches[0];
  457.             }
  459.             if ('{' === $matches['opening_brace'] && !isset($matches['closing_brace'])) {
  460.                 throw $this->createFormatException('Unclosed braces on variable expansion');
  461.             }
  463.             $name = $matches['name'];
  464.             if (isset($loadedVars[$name]) && isset($this->values[$name])) {
  465.                 $value = $this->values[$name];
  466.             } elseif (isset($_ENV[$name])) {
  467.                 $value = $_ENV[$name];
  468.             } elseif (isset($_SERVER[$name]) && 0 !== strpos($name, 'HTTP_')) {
  469.                 $value = $_SERVER[$name];
  470.             } elseif (isset($this->values[$name])) {
  471.                 $value = $this->values[$name];
  472.             } else {
  473.                 $value = (string) getenv($name);
  474.             }
  476.             if ('' === $value && isset($matches['default_value']) && '' !== $matches['default_value']) {
  477.                 $unsupportedChars = strpbrk($matches['default_value'], '\'"{$');
  478.                 if (false !== $unsupportedChars) {
  479.                     throw $this->createFormatException(sprintf('Unsupported character "%s" found in the default value of variable "$%s".', $unsupportedChars[0], $name));
  480.                 }
  482.                 $value = substr($matches['default_value'], 2);
  484.                 if ('=' === $matches['default_value'][1]) {
  485.                     $this->values[$name] = $value;
  486.                 }
  487.             }
  489.             if (!$matches['opening_brace'] && isset($matches['closing_brace'])) {
  490.                 $value .= '}';
  491.             }
  493.             return $matches['backslashes'].$value;
  494.         }, $value);
  496.         return $value;
  497.     }
  499.     private function moveCursor(string $text)
  500.     {
  501.         $this->cursor += \strlen($text);
  502.         $this->lineno += substr_count($text, "\n");
  503.     }
  505.     private function createFormatException(string $message): FormatException
  506.     {
  507.         return new FormatException($message, new FormatExceptionContext($this->data, $this->path, $this->lineno, $this->cursor));
  508.     }
  510.     private function doLoad(bool $overrideExistingVars, array $paths): void
  511.     {
  512.         foreach ($paths as $path) {
  513.             if (!is_readable($path) || is_dir($path)) {
  514.                 throw new PathException($path);
  515.             }
  517.             $this->populate($this->parse(file_get_contents($path), $path), $overrideExistingVars);
  518.         }
  519.     }
  520. }