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
32local hook = require("hook")
33
34local config = {}
35local modules = {}
36local carousel_choices = {}
37-- Which variables we changed
38local env_changed = {}
39-- Values to restore env to (nil to unset)
40local env_restore = {}
41
42local MSG_FAILEXEC = "Failed to exec '%s'"
43local MSG_FAILSETENV = "Failed to '%s' with value: %s"
44local MSG_FAILOPENCFG = "Failed to open config: '%s'"
45local MSG_FAILREADCFG = "Failed to read config: '%s'"
46local MSG_FAILPARSECFG = "Failed to parse config: '%s'"
47local MSG_FAILEXBEF = "Failed to execute '%s' before loading '%s'"
48local MSG_FAILEXAF = "Failed to execute '%s' after loading '%s'"
49local MSG_MALFORMED = "Malformed line (%d):\n\t'%s'"
50local MSG_DEFAULTKERNFAIL = "No kernel set, failed to load from module_path"
51local MSG_KERNFAIL = "Failed to load kernel '%s'"
52local MSG_XENKERNFAIL = "Failed to load Xen kernel '%s'"
53local MSG_XENKERNLOADING = "Loading Xen kernel..."
54local MSG_KERNLOADING = "Loading kernel..."
55local MSG_MODLOADING = "Loading configured modules..."
56local MSG_MODBLACKLIST = "Not loading blacklisted module '%s'"
57
58local MODULEEXPR = '([%w-_]+)'
59local QVALEXPR = "\"([%w%s%p]-)\""
60local QVALREPL = QVALEXPR:gsub('%%', '%%%%')
61local WORDEXPR = "([%w]+)"
62local WORDREPL = WORDEXPR:gsub('%%', '%%%%')
63
64local 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 = {}
89end
90
91local 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)
100end
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.
105local function setKey(key, name, value)
106	if modules[key] == nil then
107		modules[key] = {}
108	end
109	modules[key][name] = value
110end
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.
115local function escapeName(name)
116	return name:gsub("([%p])", "%%%1")
117end
118
119local 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
129end
130
131local 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
146end
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--
166local 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
254local 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
265end
266
267local 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
278end
279
280local 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
341end
342
343local 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
369end
370
371local 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
388end
389
390local 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
424end
425
426-- Module exports
427config.verbose = false
428
429-- The first item in every carousel is always the default item.
430function config.getCarouselIndex(id)
431	return carousel_choices[id] or 1
432end
433
434function config.setCarouselIndex(id, idx)
435	carousel_choices[id] = idx
436end
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.
441function 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)
452end
453
454-- silent runs will not return false if we fail to open the file
455function 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
489end
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
493function 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
588end
589
590function config.selectKernel(kernel)
591	config.kernel_selected = kernel
592end
593
594function 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
613end
614
615-- Reload configuration
616function config.reload(file)
617	modules = {}
618	restoreEnv()
619	config.load(file, true)
620	hook.runAll("config.reloaded")
621end
622
623function config.loadelf()
624	local xen_kernel = loader.getenv('xen_kernel')
625	local kernel = config.kernel_selected or config.kernel_loaded
626	local status
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	if not config.loadKernel(kernel) then
637		return false
638	end
639	hook.runAll("kernel.loaded")
640
641	print(MSG_MODLOADING)
642	status = loadModule(modules, not config.verbose)
643	hook.runAll("modules.loaded")
644	return status
645end
646
647hook.registerType("config.loaded")
648hook.registerType("config.reloaded")
649hook.registerType("kernel.loaded")
650hook.registerType("modules.loaded")
651return config
652