103 lines
2.1 KiB
Go
103 lines
2.1 KiB
Go
package host
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"lux/proto"
|
|
"lux/rpc"
|
|
)
|
|
|
|
type LuxState struct {
|
|
Hostname string
|
|
Options map[LuxOptionType]LuxOption
|
|
}
|
|
|
|
func NewLuxState(hostname string) LuxState {
|
|
return LuxState{
|
|
Hostname: hostname,
|
|
Options: make(map[LuxOptionType]LuxOption),
|
|
}
|
|
}
|
|
|
|
func (state *LuxState) Read(rd *proto.LuxBuffer) error {
|
|
// hostname
|
|
hostname, err := rd.ReadString()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state.Hostname = hostname
|
|
|
|
// option count
|
|
count, err := rd.ReadUint16()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
for i := 0; i < int(count); i++ {
|
|
// read options
|
|
opt, err := ReadLuxOption(rd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
state.Options[opt.Type()] = opt
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (state *LuxState) Write(wd *proto.LuxBuffer) {
|
|
wd.WriteString(state.Hostname)
|
|
wd.WriteUint16(uint16(len(state.Options)))
|
|
for _, opt := range state.Options {
|
|
WriteLuxOption(wd, opt)
|
|
}
|
|
}
|
|
|
|
// RPC
|
|
|
|
func (state *LuxState) IntoRpc() rpc.LuxRpcState {
|
|
rpcState := rpc.LuxRpcState{
|
|
Options: make([]rpc.LuxRpcOption, 0),
|
|
}
|
|
|
|
for optType, opt := range state.Options {
|
|
switch optType {
|
|
case LuxOptionTypeWAN:
|
|
wan := opt.(*LuxOptionWAN)
|
|
rpcState.WAN = rpc.LuxRpcWAN{
|
|
Addr4: wan.Addr4.String(),
|
|
Addr6: wan.Addr6.String(),
|
|
}
|
|
case LuxOptionTypeNetIf:
|
|
netif := opt.(*LuxOptionNetIf)
|
|
|
|
rpcState.NetIf.Interfaces = make([]rpc.LuxRpcNetInterface, 0)
|
|
for _, optIf := range netif.Interfaces {
|
|
rpcIf := rpc.LuxRpcNetInterface{
|
|
Name: optIf.Name,
|
|
Index: optIf.Index,
|
|
Addrs: make([]rpc.LuxRpcNetAddr, 0),
|
|
}
|
|
for _, optAddr := range optIf.Addrs {
|
|
rpcIf.Addrs = append(rpcIf.Addrs, rpc.LuxRpcNetAddr{
|
|
Type: optAddr.Type.String(),
|
|
Addr: optAddr.Addr.String(),
|
|
})
|
|
}
|
|
|
|
rpcState.NetIf.Interfaces = append(rpcState.NetIf.Interfaces, rpcIf)
|
|
}
|
|
default:
|
|
// encode option in base64 blob
|
|
wd := proto.NewLuxBuffer()
|
|
opt.Write(&wd)
|
|
|
|
rpcState.Options = append(rpcState.Options, rpc.LuxRpcOption{
|
|
Type: int(optType),
|
|
Blob: base64.StdEncoding.EncodeToString(wd.AllBytes()),
|
|
})
|
|
}
|
|
}
|
|
|
|
return rpcState
|
|
}
|