1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
local elf = require("elf")
local ec = require("elf.constants")
local function die(fmt, ...)
io.stderr:write("mkelf: ", string.format(fmt, ...), "\n")
os.exit(1)
end
local function usage()
die("[-o output] [input]")
end
local function setup_header(state)
return function (t)
if type(t) ~= "table" then
error("header must be a table", 2)
end
if state.header == nil then
state.header = elf.header.normalize(t)
else
error("multiple headers are disallowed", 2)
end
end
end
local function setup_segments(state)
return function (t)
if type(t) ~= "table" then
error("segments must be a table", 2)
end
for i, s in ipairs(t) do
if type(s) ~= "table" then
error(("segment #%d must be a table"):format(i), 2)
end
table.insert(state.segments, elf.segment.normalize(s))
end
end
end
local function setup_sections(state)
return function (t)
if type(t) ~= "table" then
error("sections must be a table", 2)
end
for i, s in ipairs(t) do
if type(s) ~= "table" then
error(("section #%d must be a table"):format(i), 2)
end
table.insert(state.sections, elf.section.normalize(s))
end
end
end
local function setup_env(state)
return setmetatable({}, {
__index = {
Class = ec.Class,
Endian = ec.Endian,
Osabi = ec.Osabi,
Type = ec.Type,
Machine = ec.Machine,
SegmentType = ec.SegmentType,
SegmentFlags = ec.SegmentFlags,
SectionType = ec.SectionType,
SectionFlags = ec.SectionFlags,
ELFVERSION = ec.VERSION,
header = setup_header(state),
segments = setup_segments(state),
sections = setup_sections(state),
},
__newindex = function (_, name)
error(("may not define global %q"):format(name), 2)
end,
__metatable = false,
})
end
local function loadconfig(fn)
local state = { header = nil, segments = {}, sections = {} }
local env = setup_env(state)
local chunk, err = loadfile(fn, "t", env)
if not chunk then die("%s", err) end
-- TODO sandbox against malformed configs
local ok, perr = pcall(chunk)
if not ok then die("%s", perr) end
return state.header, state.segments, state.sections
end
local function elf_pack(header, segments, sections)
local binary = elf.header.pack(header)
for _, segment in ipairs(segments) do
binary = binary .. elf.segment.pack(segment, header.class, header.endian)
end
for _, section in ipairs(sections) do
binary = binary .. elf.section.pack(section, header.class, header.endian)
end
return binary
end
local M = {}
function M.main()
local outfn = "a.out"
local infn
local i = 1
while arg[i] do
if arg[i] == "-o" then
i = i + 1
outfn = arg[i] or die("missing filename after -o")
elseif infn == nil then
infn = arg[i]
else
usage()
end
i = i + 1
end
local header, segments, sections = loadconfig(infn)
if not header then die("header missing") end
-- TODO check against headerOptions not normalized header.
-- if header.phnum == 0 then header.phnum = #segments end
-- if header.shnum == 0 then header.shnum = #sections end
local out <close>, err = io.open(outfn, "wb")
local binary = elf_pack(header, segments, sections)
if out == nil then die("failed to open: %s", outfn, err) end
local ok, werr = out:write(binary)
if not ok then die("write failed: %s", werr) end
end
return M
|