luajitos

RTL8139.lua (7847B)

---

 #!/usr/bin/env luajit
 -- RTL8139 Network Driver Library
 -- Provides high-level network interface for RTL8139 network card
 
 local RTL8139 = {}
 
 -- Driver state
 RTL8139.initialized = false
 RTL8139.mac_address = nil
 RTL8139.rx_callbacks = {}  -- Packet receive callbacks
 
 ---Initialize the RTL8139 network card
 ---@return boolean success True if initialization succeeded
 function RTL8139.init()
     if osprint then
         osprint("RTL8139.lua: Initializing network driver...\n")
     end
 
     -- Call C function to initialize hardware
     if not RTL8139Init then
         if osprint then
             osprint("RTL8139.lua: ERROR - RTL8139Init function not available\n")
         end
         return false
     end
 
     local success = RTL8139Init()
 
     if success then
         RTL8139.initialized = true
 
         -- Get MAC address
         RTL8139.mac_address = RTL8139GetMAC()
 
         if osprint then
             osprint("RTL8139.lua: Initialized successfully\n")
             if RTL8139.mac_address then
                 osprint("RTL8139.lua: MAC Address: ")
                 for i = 1, 6 do
                     osprint(string.format("%02X", RTL8139.mac_address[i]))
                     if i < 6 then osprint(":") end
                 end
                 osprint("\n")
             end
         end
     else
         if osprint then
             osprint("RTL8139.lua: Initialization failed\n")
         end
     end
 
     return success
 end
 
 ---Get the MAC address of the network card
 ---@return table|nil mac Array of 6 bytes, or nil if not initialized
 function RTL8139.getMACAddress()
     if not RTL8139.initialized then
         return nil
     end
 
     return RTL8139.mac_address
 end
 
 ---Get MAC address as a formatted string
 ---@return string|nil macString "XX:XX:XX:XX:XX:XX" format
 function RTL8139.getMACString()
     if not RTL8139.mac_address then
         return nil
     end
 
     local parts = {}
     for i = 1, 6 do
         parts[i] = string.format("%02X", RTL8139.mac_address[i])
     end
     return table.concat(parts, ":")
 end
 
 ---Send a raw Ethernet packet
 ---@param data string Raw packet data (including Ethernet header)
 ---@return number bytesent Number of bytes sent, or -1 on error
 function RTL8139.send(data)
     if not RTL8139.initialized then
         return -1
     end
 
     if type(data) ~= "string" then
         return -1
     end
 
     return RTL8139Send(data)
 end
 
 ---Receive a raw Ethernet packet (non-blocking)
 ---@return string|nil packet Raw packet data, or nil if no packet available
 function RTL8139.receive()
     if not RTL8139.initialized then
         return nil
     end
 
     return RTL8139Receive()
 end
 
 ---Register a callback for received packets
 ---@param callback function Function to call when packet is received
 ---@param filter table|nil Optional filter {ethertype = 0x0800} to filter packets
 ---@return number id Callback ID for later removal
 function RTL8139.onReceive(callback, filter)
     local id = #RTL8139.rx_callbacks + 1
     RTL8139.rx_callbacks[id] = {
         callback = callback,
         filter = filter
     }
     return id
 end
 
 ---Remove a receive callback
 ---@param id number Callback ID returned by onReceive
 function RTL8139.removeReceiveCallback(id)
     RTL8139.rx_callbacks[id] = nil
 end
 
 ---Poll for received packets and call callbacks
 ---Should be called regularly from main loop
 ---@return number count Number of packets processed
 function RTL8139.poll()
     if not RTL8139.initialized then
         return 0
     end
 
     local count = 0
 
     -- Process all available packets
     while true do
         local packet = RTL8139.receive()
         if not packet then
             break
         end
 
         count = count + 1
 
         -- Parse Ethernet header
         local eth = RTL8139.parseEthernetHeader(packet)
 
         -- Call registered callbacks
         for id, cb in pairs(RTL8139.rx_callbacks) do
             local should_call = true
 
             -- Apply filter if present
             if cb.filter then
                 if cb.filter.ethertype and eth.ethertype ~= cb.filter.ethertype then
                     should_call = false
                 end
             end
 
             if should_call then
                 local success, err = pcall(cb.callback, packet, eth)
                 if not success and osprint then
                     osprint("RTL8139.lua: Callback error: " .. tostring(err) .. "\n")
                 end
             end
         end
     end
 
     return count
 end
 
 ---Parse Ethernet header from packet
 ---@param packet string Raw packet data
 ---@return table header Ethernet header fields
 function RTL8139.parseEthernetHeader(packet)
     if #packet < 14 then
         return nil
     end
 
     local header = {}
 
     -- Destination MAC (6 bytes)
     header.dst_mac = {}
     for i = 1, 6 do
         header.dst_mac[i] = string.byte(packet, i)
     end
 
     -- Source MAC (6 bytes)
     header.src_mac = {}
     for i = 1, 6 do
         header.src_mac[i] = string.byte(packet, 6 + i)
     end
 
     -- EtherType (2 bytes, big endian)
     local b1, b2 = string.byte(packet, 13, 14)
     header.ethertype = (b1 * 256) + b2
 
     -- Payload starts at byte 15
     header.payload = string.sub(packet, 15)
 
     return header
 end
 
 ---Build an Ethernet frame
 ---@param dst_mac table Destination MAC address (6 bytes)
 ---@param src_mac table Source MAC address (6 bytes)
 ---@param ethertype number EtherType (0x0800 for IPv4, 0x0806 for ARP, etc.)
 ---@param payload string Payload data
 ---@return string frame Complete Ethernet frame
 function RTL8139.buildEthernetFrame(dst_mac, src_mac, ethertype, payload)
     local frame = {}
 
     -- Destination MAC (6 bytes)
     for i = 1, 6 do
         frame[#frame + 1] = string.char(dst_mac[i])
     end
 
     -- Source MAC (6 bytes)
     for i = 1, 6 do
         frame[#frame + 1] = string.char(src_mac[i])
     end
 
     -- EtherType (2 bytes, big endian)
     frame[#frame + 1] = string.char(math.floor(ethertype / 256))
     frame[#frame + 1] = string.char(ethertype % 256)
 
     -- Payload
     frame[#frame + 1] = payload
 
     return table.concat(frame)
 end
 
 ---Send an Ethernet frame with automatic source MAC
 ---@param dst_mac table Destination MAC address
 ---@param ethertype number EtherType
 ---@param payload string Payload data
 ---@return number bytessent Number of bytes sent
 function RTL8139.sendFrame(dst_mac, ethertype, payload)
     if not RTL8139.initialized or not RTL8139.mac_address then
         return -1
     end
 
     local frame = RTL8139.buildEthernetFrame(dst_mac, RTL8139.mac_address, ethertype, payload)
     return RTL8139.send(frame)
 end
 
 ---Send a broadcast packet
 ---@param ethertype number EtherType
 ---@param payload string Payload data
 ---@return number bytessent Number of bytes sent
 function RTL8139.sendBroadcast(ethertype, payload)
     local broadcast_mac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
     return RTL8139.sendFrame(broadcast_mac, ethertype, payload)
 end
 
 ---Common EtherType constants
 RTL8139.ETHERTYPE = {
     IPV4 = 0x0800,
     ARP = 0x0806,
     IPV6 = 0x86DD,
     VLAN = 0x8100,
 }
 
 ---Format MAC address for display
 ---@param mac table MAC address (6 bytes)
 ---@return string formatted "XX:XX:XX:XX:XX:XX"
 function RTL8139.formatMAC(mac)
     if not mac or #mac ~= 6 then
         return "00:00:00:00:00:00"
     end
 
     local parts = {}
     for i = 1, 6 do
         parts[i] = string.format("%02X", mac[i])
     end
     return table.concat(parts, ":")
 end
 
 ---Parse MAC address from string
 ---@param str string "XX:XX:XX:XX:XX:XX" format
 ---@return table|nil mac Array of 6 bytes
 function RTL8139.parseMAC(str)
     local mac = {}
     for byte_str in string.gmatch(str, "[^:]+") do
         local byte_val = tonumber(byte_str, 16)
         if not byte_val then
             return nil
         end
         mac[#mac + 1] = byte_val
     end
 
     if #mac ~= 6 then
         return nil
     end
 
     return mac
 end
 
 -- Export module
 return RTL8139