Network Card

local sys = require("sys")
local card = assert(sys.open("/dev/network0"))
print(sys.ioctl(card, "address"))  -- this card's address
sys.ioctl(card, "setWake", "letmein")

-- Keep a log of everything a network card sends and takes, each frame timed, in a file.
--
-- The card's file, /dev/network0, is its traffic: a line for each frame in or out, as
-- "in 5f0c2a9e-... 3.0m 17 taken" (the direction, the other card or "broadcast", how far, the
-- frame's bytes, and how it went). A read waits until a frame comes or goes, so the program uses
-- no time between frames. Each line is added to the log, and the log closed again, so what's
-- logged is on the disk at once (a file's writes reach the disk when it's closed).
--
-- usage: lua network-traffic.lua [log [card]]
local sys = require("sys")

local LOG = arg[1] or "/home/traffic.log"
local CARD = arg[2] or "/dev/network0"
local READ_SIZE = 512 -- the most one read takes (a line is far shorter)

local traffic = assert(sys.open(CARD))
local pending = "" -- what has been read of a line not yet ended

while true do
  local data = assert(sys.read(traffic, READ_SIZE)) -- waits for a frame
  pending = pending .. data
  for line in pending:gmatch("([^\n]*)\n") do
    local log = assert(io.open(LOG, "a"))
    log:write(string.format("%10.2f %s\n", sys.time(), line))
    log:close()
  end
  pending = pending:match("[^\n]*$")
end

-- A chat between every computer on the network: what you type goes to all of them, and what they
-- send shows here, with who sent it.
--
-- Each line typed is a UDP datagram broadcast to PORT ("name: text"), and each datagram that comes
-- in on PORT is shown. A broadcast comes back to this computer's own sockets too, so lines from its
-- own cards (their addresses, from the socket's SIOCGIFCONF ioctl) are skipped. sys.poll waits for
-- whichever comes first, the keyboard or the network, so the program uses no time while nobody
-- talks. It ends at the end of its input (Ctrl+D at the start of a line).
--
-- usage: lua network-chat.lua [name]
local sys = require("sys")

local PORT = 4000 -- every computer in the chat listens and sends here
local READ_SIZE = 4096 -- the most one read of the keyboard takes

local name = arg[1] or sys.gethostname()
local sock = assert(sys.socket()) -- UDP
assert(sys.bind(sock, PORT))

local own = {} -- this computer's cards' addresses
for _, interface in ipairs(sys.ioctl(sock, "SIOCGIFCONF")) do
  own[interface.address] = true
end

local typed = "" -- keys read, up to a line's end
local watch = {[0] = {IN = true}, [sock] = {IN = true}}
while true do
  local ready = sys.poll(watch) -- blocks until a line is typed or a datagram comes
  if ready[sock] then
    local data, from = sys.recvfrom(sock)
    if not own[from] then
      io.write(data)
      io.flush()
    end
  end
  if ready[0] then
    local keys = sys.read(0, READ_SIZE)
    if not keys or keys == "" then
      break -- the end of the input
    end
    typed = typed .. keys
    for line in typed:gmatch("([^\n]*)\n") do
      local ok, why = sys.sendto(sock, name .. ": " .. line .. "\n", "broadcast", PORT)
      if not ok then
        io.stderr:write("chat: not sent: ", why, "\n")
      end
    end
    typed = typed:match("[^\n]*$")
  end
end
sys.close(sock)

-- An echo server over TCP: everything a client sends comes back to it, for as many clients as
-- connect at once. Try it from another computer with nc: echo hello | nc <this card's id> 7
--
-- The listening socket is ready (IN) when a connection waits to be accepted, and a connection when
-- it has data or its client is done sending (a read gives "" then: the connection is closed).
-- sys.poll waits on all of them at once, so the server uses no time while nobody talks.
--
-- usage: lua network-echo.lua [port]
local sys = require("sys")

local PORT = tonumber(arg[1]) or 7 -- echo's own port
local READ_SIZE = 4096 -- the most one read of a connection takes

local server = assert(sys.socket("stream"))
assert(sys.bind(server, PORT))
assert(sys.listen(server))

-- Writes all of 'data' (a write takes what the connection has room for, and waits when it has none).
local function send(fd, data)
  while #data > 0 do
    local count = sys.write(fd, data)
    if not count then
      return false -- the client went away
    end
    data = data:sub(count + 1)
  end
  return true
end

local clients = {} -- each connection's descriptor, to its client's address
while true do
  local watch = {[server] = {IN = true}}
  for fd in pairs(clients) do
    watch[fd] = {IN = true}
  end
  local ready = sys.poll(watch)
  for fd in pairs(ready) do
    if fd == server then
      local conn, address = sys.accept(server)
      if conn then
        clients[conn] = address
      end
    else
      local data = sys.read(fd, READ_SIZE)
      if not (data and data ~= "" and send(fd, data)) then
        sys.close(fd) -- its end, or it's gone
        clients[fd] = nil
      end
    end
  end
end

-- Wake-on-LAN: get this computer ready to be turned on over the network, or turn another one on.
--
--   lua network-wol.lua enable MESSAGE    from now on, a frame holding MESSAGE turns this one on
--   lua network-wol.lua disable           it doesn't any more
--   lua network-wol.lua status            the message set, if any
--   lua network-wol.lua ADDRESS MESSAGE   turn on the computer whose card is at ADDRESS
--
-- The wake message is the card's own setting, set and read with its methods setWake and getWake,
-- which are ioctls on its file. A card with one listens while its computer is off, and a frame
-- holding the message anywhere in its data presses the power button, so a UDP datagram carrying it
-- does. The sender hears whether the card took it (EHOSTUNREACH: no card there, or it isn't
-- listening).
local sys = require("sys")

local CARD = "/dev/network0"
local PORT = 9 -- discard's port, where real wake-on-LAN packets go: no program answers there

local command, message = arg[1], arg[2]

local function fail(...)
  io.stderr:write("wol: ", ...)
  io.stderr:write("\n")
  os.exit(1)
end

if command == "enable" or command == "disable" or command == "status" then
  local card = assert(sys.open(CARD))
  if command == "status" then
    print(sys.ioctl(card, "getWake") or "(none)")
  else
    if command == "enable" and not message then
      fail("enable needs a message")
    end
    local old, why = sys.ioctl(card, "setWake", command == "enable" and message or nil)
    if old == nil and why then
      fail(why) -- (a message over 256 bytes)
    end
    print("was: " .. tostring(old or "(none)"))
  end
  sys.close(card)
elseif command and message then
  local sock = assert(sys.socket())
  local sent, why = sys.sendto(sock, message, command, PORT)
  if not sent then
    fail(command, ": ", why)
  end
  print("sent to " .. command)
else
  fail("usage: wol enable MESSAGE | disable | status | ADDRESS MESSAGE")
end