stand/lua/config.lua

   1 --
   2 -- SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3 --
   4 -- Copyright (c) 2015 Pedro Souza <pedrosouza@freebsd.org>
   5 -- Copyright (c) 2018 Kyle Evans <kevans@FreeBSD.org>
   6 -- All rights reserved.
   7 --
   8 -- Redistribution and use in source and binary forms, with or without
   9 -- modification, are permitted provided that the following conditions
  10 -- are met:
  11 -- 1. Redistributions of source code must retain the above copyright
  12 --    notice, this list of conditions and the following disclaimer.
  13 -- 2. Redistributions in binary form must reproduce the above copyright
  14 --    notice, this list of conditions and the following disclaimer in the
  15 --    documentation and/or other materials provided with the distribution.
  16 --
  17 -- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18 -- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19 -- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20 -- ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21 -- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 -- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23 -- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24 -- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25 -- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26 -- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27 -- SUCH DAMAGE.
  28 --
  29 -- $FreeBSD$
  30 --
  31
  32 local hook = require("hook")
  33
  34 local config = {}
  35 local modules = {}
  36 local carousel_choices = {}
  37 -- Which variables we changed
  38 local env_changed = {}
  39 -- Values to restore env to (nil to unset)
  40 local env_restore = {}
  41
  42 local MSG_FAILEXEC = "Failed to exec '%s'"
  43 local MSG_FAILSETENV = "Failed to '%s' with value: %s"
  44 local MSG_FAILOPENCFG = "Failed to open config: '%s'"
  45 local MSG_FAILREADCFG = "Failed to read config: '%s'"
  46 local MSG_FAILPARSECFG = "Failed to parse config: '%s'"
  47 local MSG_FAILEXBEF = "Failed to execute '%s' before loading '%s'"
  48 local MSG_FAILEXAF = "Failed to execute '%s' after loading '%s'"
  49 local MSG_MALFORMED = "Malformed line (%d):\n\t'%s'"
  50 local MSG_DEFAULTKERNFAIL = "No kernel set, failed to load from module_path"
  51 local MSG_KERNFAIL = "Failed to load kernel '%s'"
  52 local MSG_XENKERNFAIL = "Failed to load Xen kernel '%s'"
  53 local MSG_XENKERNLOADING = "Loading Xen kernel..."
  54 local MSG_KERNLOADING = "Loading kernel..."
  55 local MSG_MODLOADING = "Loading configured modules..."
  56 local MSG_MODBLACKLIST = "Not loading blacklisted module '%s'"
  57
  58 local MODULEEXPR = '([%w-_]+)'
  59 local QVALEXPR = "\"([%w%s%p]-)\""
  60 local QVALREPL = QVALEXPR:gsub('%%', '%%%%')
  61 local WORDEXPR = "([%w]+)"
  62 local WORDREPL = WORDEXPR:gsub('%%', '%%%%')
  63
  64 local function restoreEnv()
  65         -- Examine changed environment variables
  66         for k, v in pairs(env_changed) do
  67                 local restore_value = env_restore[k]
  68                 if restore_value == nil then
  69                         -- This one doesn't need restored for some reason
  70                         goto continue
  71                 end
  72                 local current_value = loader.getenv(k)
  73                 if current_value ~= v then
  74                         -- This was overwritten by some action taken on the menu
  75                         -- most likely; we'll leave it be.
  76                         goto continue
  77                 end
  78                 restore_value = restore_value.value
  79                 if restore_value ~= nil then
  80                         loader.setenv(k, restore_value)
  81                 else
  82                         loader.unsetenv(k)
  83                 end
  84                 ::continue::
  85         end
  86
  87         env_changed = {}
  88         env_restore = {}
  89 end
  90
  91 local function setEnv(key, value)
  92         -- Track the original value for this if we haven't already
  93         if env_restore[key] == nil then
  94                 env_restore[key] = {value = loader.getenv(key)}
  95         end
  96
  97         env_changed[key] = value
  98
  99         return loader.setenv(key, value)
 100 end
 101
 102 -- name here is one of 'name', 'type', flags', 'before', 'after', or 'error.'
 103 -- These are set from lines in loader.conf(5): ${key}_${name}="${value}" where
 104 -- ${key} is a module name.
 105 local function setKey(key, name, value)
 106         if modules[key] == nil then
 107                 modules[key] = {}
 108         end
 109         modules[key][name] = value
 110 end
 111
 112 -- Escapes the named value for use as a literal in a replacement pattern.
 113 -- e.g. dhcp.host-name gets turned into dhcp%.host%-name to remove the special
 114 -- meaning.
 115 local function escapeName(name)
 116         return name:gsub("([%p])", "%%%1")
 117 end
 118
 119 local function processEnvVar(value)
 120         for name in value:gmatch("${([^}]+)}") do
 121                 local replacement = loader.getenv(name) or ""
 122                 value = value:gsub("${" .. escapeName(name) .. "}", replacement)
 123         end
 124         for name in value:gmatch("$([%w%p]+)%s*") do
 125                 local replacement = loader.getenv(name) or ""
 126                 value = value:gsub("$" .. escapeName(name), replacement)
 127         end
 128         return value
 129 end
 130
 131 local function checkPattern(line, pattern)
 132         local function _realCheck(_line, _pattern)
 133                 return _line:match(_pattern)
 134         end
 135
 136         if pattern:find('$VALUE') then
 137                 local k, v, c
 138                 k, v, c = _realCheck(line, pattern:gsub('$VALUE', QVALREPL))
 139                 if k ~= nil then
 140                         return k,v, c
 141                 end
 142                 return _realCheck(line, pattern:gsub('$VALUE', WORDREPL))
 143         else
 144                 return _realCheck(line, pattern)
 145         end
 146 end
 147
 148 -- str in this table is a regex pattern.  It will automatically be anchored to
 149 -- the beginning of a line and any preceding whitespace will be skipped.  The
 150 -- pattern should have no more than two captures patterns, which correspond to
 151 -- the two parameters (usually 'key' and 'value') that are passed to the
 152 -- process function.  All trailing characters will be validated.  Any $VALUE
 153 -- token included in a pattern will be tried first with a quoted value capture
 154 -- group, then a single-word value capture group.  This is our kludge for Lua
 155 -- regex not supporting branching.
 156 --
 157 -- We have two special entries in this table: the first is the first entry,
 158 -- a full-line comment.  The second is for 'exec' handling.  Both have a single
 159 -- capture group, but the difference is that the full-line comment pattern will
 160 -- match the entire line.  This does not run afoul of the later end of line
 161 -- validation that we'll do after a match.  However, the 'exec' pattern will.
 162 -- We document the exceptions with a special 'groups' index that indicates
 163 -- the number of capture groups, if not two.  We'll use this later to do
 164 -- validation on the proper entry.
 165 --
 166 local pattern_table = {
 167         {
 168                 str = "(#.*)",
 169                 process = function(_, _)  end,
 170                 groups = 1,
 171         },
 172         --  module_load="value"
 173         {
 174                 str = MODULEEXPR .. "_load%s*=%s*$VALUE",
 175                 process = function(k, v)
 176                         if modules[k] == nil then
 177                                 modules[k] = {}
 178                         end
 179                         modules[k].load = v:upper()
 180                 end,
 181         },
 182         --  module_name="value"
 183         {
 184                 str = MODULEEXPR .. "_name%s*=%s*$VALUE",
 185                 process = function(k, v)
 186                         setKey(k, "name", v)
 187                 end,
 188         },
 189         --  module_type="value"
 190         {
 191                 str = MODULEEXPR .. "_type%s*=%s*$VALUE",
 192                 process = function(k, v)
 193                         setKey(k, "type", v)
 194                 end,
 195         },
 196         --  module_flags="value"
 197         {
 198                 str = MODULEEXPR .. "_flags%s*=%s*$VALUE",
 199                 process = function(k, v)
 200                         setKey(k, "flags", v)
 201                 end,
 202         },
 203         --  module_before="value"
 204         {
 205                 str = MODULEEXPR .. "_before%s*=%s*$VALUE",
 206                 process = function(k, v)
 207                         setKey(k, "before", v)
 208                 end,
 209         },
 210         --  module_after="value"
 211         {
 212                 str = MODULEEXPR .. "_after%s*=%s*$VALUE",
 213                 process = function(k, v)
 214                         setKey(k, "after", v)
 215                 end,
 216         },
 217         --  module_error="value"
 218         {
 219                 str = MODULEEXPR .. "_error%s*=%s*$VALUE",
 220                 process = function(k, v)
 221                         setKey(k, "error", v)
 222                 end,
 223         },
 224         --  exec="command"
 225         {
 226                 str = "exec%s*=%s*" .. QVALEXPR,
 227                 process = function(k, _)
 228                         if cli_execute_unparsed(k) ~= 0 then
 229                                 print(MSG_FAILEXEC:format(k))
 230                         end
 231                 end,
 232                 groups = 1,
 233         },
 234         --  env_var="value"
 235         {
 236                 str = "([%w%p]+)%s*=%s*$VALUE",
 237                 process = function(k, v)
 238                         if setEnv(k, processEnvVar(v)) ~= 0 then
 239                                 print(MSG_FAILSETENV:format(k, v))
 240                         end
 241                 end,
 242         },
 243         --  env_var=num
 244         {
 245                 str = "([%w%p]+)%s*=%s*(-?%d+)",
 246                 process = function(k, v)
 247                         if setEnv(k, processEnvVar(v)) ~= 0 then
 248                                 print(MSG_FAILSETENV:format(k, tostring(v)))
 249                         end
 250                 end,
 251         },
 252 }
 253
 254 local function isValidComment(line)
 255         if line ~= nil then
 256                 local s = line:match("^%s*#.*")
 257                 if s == nil then
 258                         s = line:match("^%s*$")
 259                 end
 260                 if s == nil then
 261                         return false
 262                 end
 263         end
 264         return true
 265 end
 266
 267 local function getBlacklist()
 268         local blacklist = {}
 269         local blacklist_str = loader.getenv('module_blacklist')
 270         if blacklist_str == nil then
 271                 return blacklist
 272         end
 273
 274         for mod in blacklist_str:gmatch("[;, ]?([%w-_]+)[;, ]?") do
 275                 blacklist[mod] = true
 276         end
 277         return blacklist
 278 end
 279
 280 local function loadModule(mod, silent)
 281         local status = true
 282         local blacklist = getBlacklist()
 283         local pstatus
 284         for k, v in pairs(mod) do
 285                 if v.load ~= nil and v.load:lower() == "yes" then
 286                         local module_name = v.name or k
 287                         if blacklist[module_name] ~= nil then
 288                                 if not silent then
 289                                         print(MSG_MODBLACKLIST:format(module_name))
 290                                 end
 291                                 goto continue
 292                         end
 293                         if not silent then
 294                                 loader.printc(module_name .. "...")
 295                         end
 296                         local str = "load "
 297                         if v.type ~= nil then
 298                                 str = str .. "-t " .. v.type .. " "
 299                         end
 300                         str = str .. module_name
 301                         if v.flags ~= nil then
 302                                 str = str .. " " .. v.flags
 303                         end
 304                         if v.before ~= nil then
 305                                 pstatus = cli_execute_unparsed(v.before) == 0
 306                                 if not pstatus and not silent then
 307                                         print(MSG_FAILEXBEF:format(v.before, k))
 308                                 end
 309                                 status = status and pstatus
 310                         end
 311
 312                         if cli_execute_unparsed(str) ~= 0 then
 313                                 -- XXX Temporary shim: don't break the boot if
 314                                 -- loader hadn't been recompiled with this
 315                                 -- function exposed.
 316                                 if loader.command_error then
 317                                         print(loader.command_error())
 318                                 end
 319                                 if not silent then
 320                                         print("failed!")
 321                                 end
 322                                 if v.error ~= nil then
 323                                         cli_execute_unparsed(v.error)
 324                                 end
 325                                 status = false
 326                         elseif v.after ~= nil then
 327                                 pstatus = cli_execute_unparsed(v.after) == 0
 328                                 if not pstatus and not silent then
 329                                         print(MSG_FAILEXAF:format(v.after, k))
 330                                 end
 331                                 if not silent then
 332                                         print("ok")
 333                                 end
 334                                 status = status and pstatus
 335                         end
 336                 end
 337                 ::continue::
 338         end
 339
 340         return status
 341 end
 342
 343 local function readConfFiles(loaded_files)
 344         local f = loader.getenv("loader_conf_files")
 345         if f ~= nil then
 346                 for name in f:gmatch("([%w%p]+)%s*") do
 347                         if loaded_files[name] ~= nil then
 348                                 goto continue
 349                         end
 350
 351                         local prefiles = loader.getenv("loader_conf_files")
 352
 353                         print("Loading " .. name)
 354                         -- These may or may not exist, and that's ok. Do a
 355                         -- silent parse so that we complain on parse errors but
 356                         -- not for them simply not existing.
 357                         if not config.processFile(name, true) then
 358                                 print(MSG_FAILPARSECFG:format(name))
 359                         end
 360
 361                         loaded_files[name] = true
 362                         local newfiles = loader.getenv("loader_conf_files")
 363                         if prefiles ~= newfiles then
 364                                 readConfFiles(loaded_files)
 365                         end
 366                         ::continue::
 367                 end
 368         end
 369 end
 370
 371 local function readFile(name, silent)
 372         local f = io.open(name)
 373         if f == nil then
 374                 if not silent then
 375                         print(MSG_FAILOPENCFG:format(name))
 376                 end
 377                 return nil
 378         end
 379
 380         local text, _ = io.read(f)
 381         -- We might have read in the whole file, this won't be needed any more.
 382         io.close(f)
 383
 384         if text == nil and not silent then
 385                 print(MSG_FAILREADCFG:format(name))
 386         end
 387         return text
 388 end
 389
 390 local function checkNextboot()
 391         local nextboot_file = loader.getenv("nextboot_conf")
 392         if nextboot_file == nil then
 393                 return
 394         end
 395
 396         local text = readFile(nextboot_file, true)
 397         if text == nil then
 398                 return
 399         end
 400
 401         if text:match("^nextboot_enable=\"NO\"") ~= nil then
 402                 -- We're done; nextboot is not enabled
 403                 return
 404         end
 405
 406         if not config.parse(text) then
 407                 print(MSG_FAILPARSECFG:format(nextboot_file))
 408         end
 409
 410         -- Attempt to rewrite the first line and only the first line of the
 411         -- nextboot_file. We overwrite it with nextboot_enable="NO", then
 412         -- check for that on load.
 413         -- It's worth noting that this won't work on every filesystem, so we
 414         -- won't do anything notable if we have any errors in this process.
 415         local nfile = io.open(nextboot_file, 'w')
 416         if nfile ~= nil then
 417                 -- We need the trailing space here to account for the extra
 418                 -- character taken up by the string nextboot_enable="YES"
 419                 -- Or new end quotation mark lands on the S, and we want to
 420                 -- rewrite the entirety of the first line.
 421                 io.write(nfile, "nextboot_enable=\"NO\" ")
 422                 io.close(nfile)
 423         end
 424 end
 425
 426 -- Module exports
 427 config.verbose = false
 428
 429 -- The first item in every carousel is always the default item.
 430 function config.getCarouselIndex(id)
 431         return carousel_choices[id] or 1
 432 end
 433
 434 function config.setCarouselIndex(id, idx)
 435         carousel_choices[id] = idx
 436 end
 437
 438 -- Returns true if we processed the file successfully, false if we did not.
 439 -- If 'silent' is true, being unable to read the file is not considered a
 440 -- failure.
 441 function config.processFile(name, silent)
 442         if silent == nil then
 443                 silent = false
 444         end
 445
 446         local text = readFile(name, silent)
 447         if text == nil then
 448                 return silent
 449         end
 450
 451         return config.parse(text)
 452 end
 453
 454 -- silent runs will not return false if we fail to open the file
 455 function config.parse(text)
 456         local n = 1
 457         local status = true
 458
 459         for line in text:gmatch("([^\n]+)") do
 460                 if line:match("^%s*$") == nil then
 461                         for _, val in ipairs(pattern_table) do
 462                                 local pattern = '^%s*' .. val.str .. '%s*(.*)';
 463                                 local cgroups = val.groups or 2
 464                                 local k, v, c = checkPattern(line, pattern)
 465                                 if k ~= nil then
 466                                         -- Offset by one, drats
 467                                         if cgroups == 1 then
 468                                                 c = v
 469                                                 v = nil
 470                                         end
 471
 472                                         if isValidComment(c) then
 473                                                 val.process(k, v)
 474                                                 goto nextline
 475                                         end
 476
 477                                         break
 478                                 end
 479                         end
 480
 481                         print(MSG_MALFORMED:format(n, line))
 482                         status = false
 483                 end
 484                 ::nextline::
 485                 n = n + 1
 486         end
 487
 488         return status
 489 end
 490
 491 -- other_kernel is optionally the name of a kernel to load, if not the default
 492 -- or autoloaded default from the module_path
 493 function config.loadKernel(other_kernel)
 494         local flags = loader.getenv("kernel_options") or ""
 495         local kernel = other_kernel or loader.getenv("kernel")
 496
 497         local function tryLoad(names)
 498                 for name in names:gmatch("([^;]+)%s*;?") do
 499                         local r = loader.perform("load " .. name ..
 500                              " " .. flags)
 501                         if r == 0 then
 502                                 return name
 503                         end
 504                 end
 505                 return nil
 506         end
 507
 508         local function getModulePath()
 509                 local module_path = loader.getenv("module_path")
 510                 local kernel_path = loader.getenv("kernel_path")
 511
 512                 if kernel_path == nil then
 513                         return module_path
 514                 end
 515
 516                 -- Strip the loaded kernel path from module_path. This currently assumes
 517                 -- that the kernel path will be prepended to the module_path when it's
 518                 -- found.
 519                 kernel_path = escapeName(kernel_path .. ';')
 520                 return module_path:gsub(kernel_path, '')
 521         end
 522
 523         local function loadBootfile()
 524                 local bootfile = loader.getenv("bootfile")
 525
 526                 -- append default kernel name
 527                 if bootfile == nil then
 528                         bootfile = "kernel"
 529                 else
 530                         bootfile = bootfile .. ";kernel"
 531                 end
 532
 533                 return tryLoad(bootfile)
 534         end
 535
 536         -- kernel not set, try load from default module_path
 537         if kernel == nil then
 538                 local res = loadBootfile()
 539
 540                 if res ~= nil then
 541                         -- Default kernel is loaded
 542                         config.kernel_loaded = nil
 543                         return true
 544                 else
 545                         print(MSG_DEFAULTKERNFAIL)
 546                         return false
 547                 end
 548         else
 549                 -- Use our cached module_path, so we don't end up with multiple
 550                 -- automatically added kernel paths to our final module_path
 551                 local module_path = getModulePath()
 552                 local res
 553
 554                 if other_kernel ~= nil then
 555                         kernel = other_kernel
 556                 end
 557                 -- first try load kernel with module_path = /boot/${kernel}
 558                 -- then try load with module_path=${kernel}
 559                 local paths = {"/boot/" .. kernel, kernel}
 560
 561                 for _, v in pairs(paths) do
 562                         loader.setenv("module_path", v)
 563                         res = loadBootfile()
 564
 565                         -- succeeded, add path to module_path
 566                         if res ~= nil then
 567                                 config.kernel_loaded = kernel
 568                                 if module_path ~= nil then
 569                                         loader.setenv("module_path", v .. ";" ..
 570                                             module_path)
 571                                         loader.setenv("kernel_path", v)
 572                                 end
 573                                 return true
 574                         end
 575                 end
 576
 577                 -- failed to load with ${kernel} as a directory
 578                 -- try as a file
 579                 res = tryLoad(kernel)
 580                 if res ~= nil then
 581                         config.kernel_loaded = kernel
 582                         return true
 583                 else
 584                         print(MSG_KERNFAIL:format(kernel))
 585                         return false
 586                 end
 587         end
 588 end
 589
 590 function config.selectKernel(kernel)
 591         config.kernel_selected = kernel
 592 end
 593
 594 function config.load(file, reloading)
 595         if not file then
 596                 file = "/boot/defaults/loader.conf"
 597         end
 598
 599         if not config.processFile(file) then
 600                 print(MSG_FAILPARSECFG:format(file))
 601         end
 602
 603         local loaded_files = {file = true}
 604         readConfFiles(loaded_files)
 605
 606         checkNextboot()
 607
 608         local verbose = loader.getenv("verbose_loading") or "no"
 609         config.verbose = verbose:lower() == "yes"
 610         if not reloading then
 611                 hook.runAll("config.loaded")
 612         end
 613 end
 614
 615 -- Reload configuration
 616 function config.reload(file)
 617         modules = {}
 618         restoreEnv()
 619         config.load(file, true)
 620         hook.runAll("config.reloaded")
 621 end
 622
 623 function config.loadelf()
 624         local xen_kernel = loader.getenv('xen_kernel')
 625         local kernel = config.kernel_selected or config.kernel_loaded
 626         local loaded
 627
 628         if xen_kernel ~= nil then
 629                 print(MSG_XENKERNLOADING)
 630                 if cli_execute_unparsed('load ' .. xen_kernel) ~= 0 then
 631                         print(MSG_XENKERNFAIL:format(xen_kernel))
 632                         return false
 633                 end
 634         end
 635         print(MSG_KERNLOADING)
 636         loaded = config.loadKernel(kernel)
 637
 638         if not loaded then
 639                 return false
 640         end
 641
 642         print(MSG_MODLOADING)
 643         return loadModule(modules, not config.verbose)
 644 end
 645
 646 hook.registerType("config.loaded")
 647 hook.registerType("config.reloaded")
 648 return config