269 lines
6.3 KiB
Crystal
269 lines
6.3 KiB
Crystal
|
||
@[Link("ipc")]
|
||
lib LibIPC
|
||
struct Service
|
||
version : LibC::UInt
|
||
index : LibC::UInt
|
||
spath : LibC::Char[4096] # [PATH_MAX]
|
||
fd : LibC::Int
|
||
end
|
||
|
||
struct Client
|
||
version : LibC::UInt
|
||
index : LibC::UInt
|
||
fd : LibC::Int
|
||
end
|
||
|
||
struct Message
|
||
type : LibC::Char
|
||
length : LibC::UShort
|
||
payload : LibC::Char*
|
||
end
|
||
|
||
struct Clients
|
||
clients : Client**
|
||
size : LibC::Int
|
||
end
|
||
|
||
# FIXME: IPC.initialize:
|
||
# - throw exceptions on error.
|
||
# - Make most arguments optional.
|
||
fun ipc_server_init(env : LibC::Char**, service : Service*, sname : LibC::Char*) : LibC::Int
|
||
# FIXME: IPC.(destroy?)
|
||
fun ipc_server_close(Service*) : LibC::Int
|
||
fun ipc_server_close_client(Client*) : LibC::Int
|
||
|
||
fun ipc_server_accept(Service*, Client*) : LibC::Int
|
||
fun ipc_server_read(Client*, Message*) : LibC::Int
|
||
fun ipc_server_write(Client*, Message*) : LibC::Int
|
||
|
||
fun ipc_server_select(Clients*, Service*, Clients*, LibC::Int*) : LibC::Int
|
||
|
||
fun ipc_application_connection(LibC::Char**, Service*, LibC::Char*) : LibC::Int
|
||
fun ipc_application_close(Service*) : LibC::Int
|
||
fun ipc_application_read(Service*, Message*) : LibC::Int
|
||
fun ipc_application_write(Service*, Message*) : LibC::Int
|
||
|
||
fun ipc_client_add(Clients*, Client*) : LibC::Int
|
||
fun ipc_client_del(Clients*, Client*) : LibC::Int
|
||
|
||
fun ipc_server_client_copy(Client*) : Client*
|
||
fun ipc_server_client_eq(Client*, Client*) : LibC::Int
|
||
|
||
fun ipc_server_client_gen(Client*, LibC::UInt, LibC::UInt)
|
||
|
||
fun ipc_clients_free(Clients*)
|
||
end
|
||
|
||
class IPC::Exception < ::Exception
|
||
|
||
end
|
||
|
||
class IPC::Service
|
||
@closed = false
|
||
@clients = LibIPC::Clients.new
|
||
# FIXME: getter only as long as proper bindings are unfinished
|
||
getter service = LibIPC::Service.new
|
||
|
||
def initialize(name : String)
|
||
if LibIPC.ipc_server_init(LibC.environ, pointerof(@service), name) < 0
|
||
raise Exception.new "ipc_server_init < 0" # FIXME: Add proper descriptions here.
|
||
end
|
||
|
||
# Very important as there are filesystem side-effects.
|
||
at_exit { close }
|
||
end
|
||
|
||
def initialize(name : String, &block : Proc(IPC::Event::Connection | IPC::Event::Disconnection | IPC::Event::Message, Nil))
|
||
initialize name
|
||
loop &block
|
||
close
|
||
end
|
||
|
||
def close
|
||
return if @closed
|
||
|
||
# FIXME: Probably check it’s not been closed already.
|
||
if LibIPC.ipc_server_close(pointerof(@service)) < 0
|
||
raise Exception.new "ipc_server_close < 0"
|
||
end
|
||
|
||
@closed = true
|
||
end
|
||
def finalize
|
||
close
|
||
end
|
||
|
||
def accept
|
||
::IPC::Server::Client.new pointerof(@service)
|
||
end
|
||
|
||
def loop(&block)
|
||
active_clients = LibIPC::Clients.new
|
||
anyone_joined = 0_i32
|
||
message = LibIPC::Message.new
|
||
|
||
::loop do
|
||
if LibIPC.ipc_server_select(pointerof(@clients), pointerof(@service), pointerof(active_clients), pointerof(anyone_joined)) < 0
|
||
raise Exception.new "ipc_server_select < 0"
|
||
end
|
||
|
||
if anyone_joined > 0
|
||
client = LibIPC::Client.new
|
||
if LibIPC.ipc_server_accept(pointerof(@service), pointerof(client)) < 0
|
||
raise Exception.new "ipc_server_accept < 0"
|
||
end
|
||
|
||
if LibIPC.ipc_client_add(pointerof(@clients), pointerof(client)) < 0
|
||
raise Exception.new "ipc_client_add < 0"
|
||
end
|
||
|
||
yield ::IPC::Event::Connection.new ::IPC::Server::Client.new client
|
||
end
|
||
|
||
i = 0
|
||
while i < active_clients.size
|
||
client_pointer = active_clients.clients[i]
|
||
|
||
return_value = LibIPC.ipc_server_read(client_pointer, pointerof(message))
|
||
|
||
if return_value < 0
|
||
raise Exception.new "ipc_server_read < 0"
|
||
elsif return_value == 1
|
||
LibIPC.ipc_client_del pointerof(@clients), client_pointer
|
||
|
||
# FIXME: Should probably not be a new Server::Client. Having unique
|
||
# variables helps in using Server::Clients as keys.
|
||
yield Event::Disconnection.new Server::Client.new client_pointer.value
|
||
else
|
||
yield Event::Message.new(IPC::Message.new(message.type, message.length, message.payload), Server::Client.new client_pointer.value)
|
||
end
|
||
|
||
i += 1
|
||
end
|
||
|
||
LibIPC.ipc_clients_free(pointerof(active_clients))
|
||
end
|
||
|
||
close
|
||
end
|
||
end
|
||
|
||
class IPC::Message
|
||
enum Type
|
||
CLOSE
|
||
CONNECTION
|
||
SYN
|
||
ACK
|
||
DATA
|
||
end
|
||
|
||
getter type : UInt8
|
||
getter payload : String
|
||
|
||
def initialize(type, length, payload)
|
||
@type = type
|
||
@payload = String.new payload, length
|
||
end
|
||
end
|
||
|
||
class IPC::Server::Client
|
||
@closed = false
|
||
getter client = LibIPC::Client.new
|
||
|
||
def initialize(service : LibIPC::Service*)
|
||
if LibIPC.ipc_server_accept(service, pointerof(@client)) < 0
|
||
raise Exception.new "ipc_server_accept < 0"
|
||
end
|
||
end
|
||
def initialize(@client)
|
||
end
|
||
|
||
def read
|
||
message = LibIPC::Message.new
|
||
|
||
if LibIPC.ipc_server_read(pointerof(@client), pointerof(message)) < 0
|
||
raise Exception.new "ipc_server_read < 0"
|
||
end
|
||
|
||
Message.new message.type, message.length, message.payload
|
||
end
|
||
def send(type : UInt8, payload : String)
|
||
message = LibIPC::Message.new type: type, length: payload.size, payload: payload.to_unsafe
|
||
|
||
if LibIPC.ipc_server_write(pointerof(@client), pointerof(message)) < 0
|
||
raise Exception.new "ipc_server_write < 0"
|
||
end
|
||
end
|
||
def close
|
||
return if @closed
|
||
|
||
LibIPC.ipc_server_close_client pointerof(@client)
|
||
end
|
||
def finalize
|
||
close
|
||
end
|
||
end
|
||
|
||
class IPC::Event
|
||
class Connection
|
||
getter client : ::IPC::Server::Client
|
||
def initialize(@client)
|
||
end
|
||
end
|
||
|
||
class Disconnection
|
||
getter client : ::IPC::Server::Client
|
||
def initialize(@client)
|
||
end
|
||
end
|
||
|
||
class Message
|
||
getter message : ::IPC::Message
|
||
getter client : ::IPC::Server::Client
|
||
def initialize(@message, @client)
|
||
end
|
||
end
|
||
end
|
||
|
||
class IPC::Client
|
||
@service = LibIPC::Service.new
|
||
|
||
def initialize(@service_name : String)
|
||
if LibIPC.ipc_application_connection(LibC.environ, pointerof(@service), @service_name) < 0
|
||
raise Exception.new "ipc_application_connection < 0"
|
||
end
|
||
end
|
||
def initialize(name, &block)
|
||
initialize(name)
|
||
|
||
yield self
|
||
|
||
close
|
||
end
|
||
|
||
def send(type, payload : String)
|
||
message = LibIPC::Message.new type: type, length: payload.size, payload: payload.to_unsafe
|
||
|
||
if LibIPC.ipc_application_write(pointerof(@service), pointerof(message)) < 0
|
||
raise Exception.new "ipc_application_write < 0"
|
||
end
|
||
end
|
||
|
||
def read
|
||
message = LibIPC::Message.new
|
||
if LibIPC.ipc_application_read(pointerof(@service), pointerof(message)) < 0
|
||
raise Exception.new "ipc_application_read < 0"
|
||
end
|
||
|
||
IPC::Message.new message.type, message.length, message.payload
|
||
end
|
||
|
||
def close
|
||
if LibIPC.ipc_application_close(pointerof(@service)) < 0
|
||
raise Exception.new "ipc_application_close < 0"
|
||
end
|
||
end
|
||
end
|
||
|