summaryrefslogtreecommitdiffstats
path: root/interfaces-model.lua
blob: 5c1028366e219e40593d641a42d3060d8dcc76c4 (plain)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
-- acf model for /etc/network/interfaces 
-- Copyright(c) 2007 N. Angelacos - Licensed under terms of GPL2
module (..., package.seeall)

require("modelfunctions")
require("fs")

-- iface is a local (private) table with private methods for managing
-- the interfaces file.  All low-level stuff is done here.  It exposes
-- the iface.tags, file(raw), and array (parsed), as well as a number
-- of functions for managing the interface file. These are in a local
-- table because nobody outside the model should know anything about 
-- the interfaces file (not even where it is - it could be in an LDAP 
-- directory for all we know) The public module functions are defined
-- further below

local iface = {	tags = { comment = {type="longtext", label="Comments"},
			auto = {type="boolean", value=false, label="Auto bring-up"},
			name = {label="Interface Name"},
			family = {type="select", label="Address Family", option={"inet", "ipx", "inet6"}}, 
			['pre-up'] = {type="longtext", label="'pre-up' actions"},
			up = {type="longtext", label="'up' actions"},
			down = {type="longtext", label="'down' actions"}, 
			['post-down'] = {type="longtext", label="'post-down' actions"} },
		method_tag = {type="select", label="Method"}, 
		family_methods = { inet = {"loopback", "static", "manual", 
				"dhcp", "bootp", "ppp", "wvdial"},
			ipx = {"static", "dynamic"},
			inet6 = {"loopback", "static", "manual", "v4tunnel"} },
		method_options = {inet = {loopback = {},
					static = {address = {label="Address"},
						netmask = {label="Netmask"},
						broadcast = {label="Broadcast address"},
						network = {label="Network address"},
						metric = {label="Routing metric"},
						gateway = {label="Default gateway"},
						pointopoint = {label="Point-to-point address"},
						media = {label="Medium type"},
						hwaddress = {label="Hardware address"},
						mtu = {label="MTU size"} },
					manual = {},
					dhcp = {hostname = {label="Hostname"},
						leasehours = {label="Preferred lease time (hours)"},
						leasetime = {label="Preferred lease time (seconds)"},
						vendor = {label="Vendor class identifier"},
						client = {label="Client identifier"},
						hwaddress = {label="Hardware address"} },
					bootp = {bootfile = {label="Boot file"},
						server = {label="Server address"},
						hwaddr = {label="Hardware address"} },
					ppp = {provider = {label="Provider name"} },
					wvdial = {provider = {label="Provider name"} },
					},
				ipx = {	static = {frame = {label="Ethernet frame type"},
						netnum = {label="Network number"} },
					dynamic = {frame = {label="Ethernet frame type"} },
					},
				inet6 ={loopback = {},
					static = {address = {label="Address"},
						netmask = {label="Netmask"},
						gateway = {label="Default gateway"},
						media = {label="Medium type"},
						hwaddress = {label="Hardware address"},
						mtu = {label="MTU size"} },
					manual = {},
					v4tunnel = {address = {label="Address"},
						netmask = {label="Netmask"},
						endpoint = {label="Endpoint address"},
						['local'] = {label="Local address"},
						gateway = {label="Default gateway"},
						ttl = {label="TTL setting"} },
					},
				},
		-- lowlevel functions will insert file and array here
		}


-- Lowlevel functions - they do things directly to iface.
local filename = "/etc/network/interfaces" 
iface.read_file = function ()
	iface.file = cfe({ type="longtext", label=filename })
	local file = io.open(filename)
	local rc = false
	if file then
		iface.file.value = file:read("*a")
		-- make sure it has a terminating \n
		iface.file.value  = string.gsub (iface.file.value, "([^\n])$", "%1\n")
		file:close()
		rc = true
	end
	return rc
end

iface.write_file = function ()
	local rc = false
	local file = io.open ( iface.file.label, "w")
	if file then
		file:write ( iface.file.value )
		file:close()
		rc = true
	end
	return rc
end

iface.iface_type = function (family, method)
	local f =  {}
	for name,table in pairs(iface.tags) do
		f[name] = cfe(table)
	end

	f.family.value = family or ""
	if family and iface.family_methods[family] then
		f.method = cfe(iface.method_tag)
		f.method.option = iface.family_methods[family]
		f.method.value = method or ""

		if method and iface.method_options[family][method] then
			for name,table in pairs(iface.method_options[family][method]) do
				f[name] = cfe(table)
			end
		elseif method then
			f.method.errtxt = "Invalid method"
		end
	elseif family then
		f.family.errtxt = "Invalid family"
	end
	
	return cfe({ type="group", value=f, label="Interface description" })
end

-- return true or false + the index of iface.array matching "name"
iface.index = function (name)
	if name and #name > 0  then
		if iface.array == nil then
			iface.unpack_interfaces ()
		end

		for k,v in ipairs(iface.array) do
			if name == v.value.name.value then
				return true, k
			end
		end
	end

	return false, 0
end


iface.append  = function (self, value, prefix)
	self = self or ""
	-- if we already have some values, then append a newline
	if #self > 0  then self = self .. "\n" end
	-- strip the prefix
	local str = string.gsub(value, "^" .. ( prefix or "" ), "")
	-- and append
	return self .. str 
end

iface.expand = function (self, prefix)
	if #self == 0 then
		return ""
	end
	-- force the string to end in a single linefeed
	self = string.gsub (self, "\r", "")
	self = string.gsub (self, "[\n]*$", "\n")
	local strings = {}
	for line in string.gmatch(self, "(.-)\n") do
		if #line > 0 then
			strings[#strings+1] = prefix .. " " .. line
		end
	end
	return table.concat(strings, "\n")
end

iface.unpack_interfaces = function ()
	if iface.array == nil then
		iface.read_file()
		iface.array = {}
	
		-- call it array so we don't have to call it iface.array everywhere
		local array = iface.array
		local comment = ""
		local auto = {}

		for line in string.gmatch ( iface.file.value, "%s*([^\n]*%S)%s*\n?") do
			-- it can be #, auto, iface, or a parameter
			if string.match(line, "^#") then
				comment = iface.append(comment, line , "#%s*" )
			elseif string.match(line, "^auto") then
				local name = string.match(line, "auto%s+(%S+)")
				auto[name] = true
			elseif string.match(line, "^iface") then
				local name, family, method = string.match(line, "%S+%s+(%S+)%s+(%S+)%s+(%S+)")
				array[#array + 1] = iface.iface_type(family, method)
				local interface = array[#array].value
				interface.comment.value = comment
				comment = ""
				interface.name.value = name or ""
			elseif #array then
				-- it must be some kind of parameter
				local param, val = 
					string.match(line, "(%S+)%s*(.*)$")
				if (param) then
					local interface = array[#array].value
					if comment ~= "" then
						interface.comment.value = iface.append(interface.comment.value, comment)
						comment = ""
					end
					if not (interface[param]) then
						interface[param] = cfe({label=param, errtxt = "Unknown parameter"})
					end
					interface[param].value = 
						iface.append (interface[param].value, val)
				end
			end
		end
		for i,int in ipairs(array) do
			if auto[int.value.name.value] then
				int.value.auto.value = true
			end
		end
	end

	return cfe({ type="list", value=iface.array, label="Interfaces" })
end

iface.pack_interfaces = function ()
	local str = ""
	local strings = {}
	for n,int in ipairs(iface.array) do
		local me = int.value
		if me.comment.value ~= "" then
			strings[#strings+1] = iface.expand(me.comment.value, "#")
		end
		if me.auto.value then
			strings[#strings+1] = "auto " .. me.name.value
		end
		strings[#strings+1] = string.format("iface %s %s %s", me.name.value,
						me.family.value, me.method.value)
		for name,entry in pairs(me) do
			if name~="comment" and name~="name" and name~="family" and name~="method" and name~="auto"
				and entry.value ~= "" then
				strings[#strings+1] = iface.expand(entry.value, "\t"..name)
			end
		end
		strings[#strings+1] = ""
	end

	return table.concat(strings, "\n")
end

iface.commit = function ()
	iface.file.value = iface.pack_interfaces()
	return iface.write_file() 
end


iface.add_after = function (def, name)
	-- if the new def.name is already in the table, then fail
	local rc, idx = iface.index(def.value.name.value)
	if rc == true then
		def.value.name.errtxt = "This interface is already defined"
		rc = false
	else
		rc, def = iface.validate( def )
	end

	-- if the name to insert after doesn't exist, just add it to the end
	if rc then
		rc, idx = iface.index(name)
		if rc == false then
			idx = #iface.array
		end
		table.insert( iface.array, idx+1, def )
		rc = iface.commit()
	end

	if rc == false then
		def.errtxt = "Failed to create interface"
	end

	return def
end

iface.read = function (name)
	-- if the name is blank, then return a blank iface with error
	iface.unpack_interfaces()
	local rc, idx = iface.index(name)
	if rc == false then
		local ret = iface.iface_type()
		ret.value.name.value = name
		ret.value.name.errtxt = "Interface does not exist"
		return ret
	end
	return iface.array[idx]
end


iface.update = function (def)
	-- if the def by that name doesn't exist, fail
	local rc, idx = iface.index(def.value.name.value or "" )
	if rc == false then
		def.value.name.errtxt = "This is an invalid interface name"
	else
		rc, def = iface.validate ( def )
	end

	if rc then
		iface.array[idx] = def
		rc = iface.commit()
	end

	if rc == false then
		def.errtxt = "Failed to update interface"
	end

	return def
end

iface.delete = function (name)
	local rc, idx = iface.index(name)
	if rc then
		table.remove (iface.array, idx ) 
		rc = iface.commit()
	end
	local value
	if rc then
		value = "Interface deleted"
	else
		value = "Interface not found"
	end
	return cfe({ value=value, label="Delete result" })
end


iface.validate  = function (def)
	local success = true
	-- since the structure is different depending on the family and method ...
	local method = ""
	if def.value.method then method = def.value.method.value end
	local newdef = iface.iface_type(def.value.family.value, method)
	for name,option in pairs(newdef.value) do
		if option.errtxt then
			success = false
		end
		if def.value[name] then
			option.value = def.value[name].value
		end
	end

	-- Now, start to validate (family and method already validated)
	if #newdef.value.name.value == 0 then
		newdef.value.name.errtxt = "The interface must have a name"
		success = false
	elseif string.find(newdef.value.name.value, "%s") then
		newdef.value.name.errtxt = "Cannot contain spaces"
		success = false
	end
	-- More validation tests go here ---
	--

	if not success then
		newdef.errtxt = "Failed validation"
	end

	return success, newdef
end

iface.ifup = function (name)
	name = name or ""
	local cmd = "PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin ifup "..name
	local f = io.popen(cmd)
	local cmdresult = f:read("*a")
	f:close()

	if cmdresult == "" then
		cmdresult = "Interface up"
	end

	return cfe({ type="longtext", value=cmdresult, label="ifup "..name })
end

iface.ifdown = function (name)
	name = name or ""
	local cmd = "PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin ifdown "..name
	local f = io.popen(cmd)
	local cmdresult = f:read("*a")
	f:close()

	if cmdresult == "" then
		cmdresult = "Interface down"
	end

	return cfe({ type="longtext", value=cmdresult, label="ifdown "..name })
end

iface.ipaddr = function ()
	local cmd = "PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin ip addr"
	local f = io.popen(cmd)
	local cmdresult = f:read("*a")
	f:close()

	return cfe({ type="longtext", value=cmdresult, label="ip addr" })
end

iface.iproute = function ()
	local cmd = "PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin ip route"
	local f = io.popen(cmd)
	local cmdresult = f:read("*a")
	f:close()

	return cfe({ type="longtext", value=cmdresult, label="ip route" })
end

iface.ifconfig = function ()
	local cmd = "PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin ifconfig"
	local f = io.popen(cmd)
	local cmdresult = f:read("*a")
	f:close()

	return cfe({ type="longtext", value=cmdresult, label="ifconfig" })
end

-------------------------------------------------------------------------------
-- Public Methods 
-------------------------------------------------------------------------------

get_all_interfaces	= iface.unpack_interfaces

get_iface_by_name	= iface.read

get_iface		= iface.iface_type

create_iface		= iface.add_after

update_iface		= iface.update

delete_iface_by_name	= iface.delete

ifup_by_name		= iface.ifup

ifdown_by_name		= iface.ifdown

get_status = function ()
	local interfacesfile = cfe({
		label="Interfaces file",
		value=filename,
	})
	if not fs.is_file(filename) then
		interfacesfile.errtxt = "File not found"
	end
	return cfe({ type="group", value={filename=interfacesfile, ipaddr=iface.ipaddr(), iproute=iface.iproute()}, label="Status" })
end

get_file = function ()
	if not iface.file then
		iface.read_file()
	end
	
	local file = cfe({ value=filename, label="Interfaces file" })
	local filesize = cfe({ value="0", label="File size" })
	local mtime = cfe({ value="---", label="File date" })
	local filedetails = fs.stat(filename)
	if filedetails then
		filesize.value = filedetails.size
		mtime.value = filedetails.mtime
	else
		file.errtxt = "File not found"
	end

	return cfe({ type="group", value={filename=file, filecontent=iface.file, filesize=filesize, mtime=mtime}, label="Interfaces file details" })
end

write_file = function (newfile)
	if not iface.file then
		iface.read_file()
	end
	iface.file.value = newfile.value.filecontent.value
	iface.write_file()

	return get_file()
end

get_addresses = function()
	local ipaddr = iface.ipaddr()
	-- now parse the result to find the interfaces and IP addresses
	local retval = {}
	local interface
	for line in string.gmatch(ipaddr.value, "[^\n]*\n?") do
		if string.find(line, "^%d+:%s+") then
			interface=string.match(line, "^%d+:%s+([^:@]+)")
		elseif string.find(line, "^%s*inet%s") then
			table.insert(retval, {interface=interface, ipaddr=string.match(line, "^%s*inet%s+([%d%.]+)")})
		end
	end
	return cfe({ type="structure", value=retval, label="Interface IP Addresses" })
end

restartnetworking = function()
	return modelfunctions.startstop_service("networking", "restart")
end