/*
handleLockMessage handles the logic upon receiving a LockMessage. Notably this
includes allowing or disallowing a lock for a specific time frame.
*/
func (c *chaninterface) handleLockMessage(address string, lm *shared.LockMessage) {
switch lm.Action {
case shared.LoRequest:
if c.enc.isLockedAddress(address) {
// we catch this to avoid having peers trying to sync multiple times at the same time
log.Println("Relock tried for same address, ignoring!")
return
}
if c.enc.setLock(address) {
// if successful notify peer of success
accept := shared.CreateLockMessage(shared.LoAccept)
c.enc.channel.Send(address, accept.JSON())
}
// if not successful send release to signify that peer has no lock
deny := shared.CreateLockMessage(shared.LoRelease)
c.enc.channel.Send(address, deny.JSON())
return
case shared.LoRelease:
if c.enc.isLockedAddress(address) {
c.enc.ClearLock()
// TODO notify of clear?
return
}
log.Println("handleLockMessage: WARNING: received release request from invalid peer!", address[:8])
default:
log.Println("handleLockMessage: Invalid action received!")
}
}
func (c *chaninterface) OnMessage(address, message string) {
// check if lock message, or request, or send message
v := &shared.Message{}
err := json.Unmarshal([]byte(message), v)
if err == nil {
// special case for lock messages (can be received if not locked)
if v.Type == shared.MsgLock {
msg := &shared.LockMessage{}
err := json.Unmarshal([]byte(message), msg)
if err != nil {
log.Println("OnMessage: failed to parse JSON!", err)
return
}
c.handleLockMessage(address, msg)
return
}
// for all others ensure that we are locked correctly
if !c.enc.checkLock(address) {
// if not warn and ignore message
log.Println("OnMessage: not locked to given address!", address[:8])
// TODO send notify that they are unlocked back?
return
}
// if correctly locked handle message according to type
switch msgType := v.Type; msgType {
case shared.MsgRequest:
msg := &shared.RequestMessage{}
err := json.Unmarshal([]byte(message), msg)
if err != nil {
log.Println("OnMessage: failed to parse JSON!", err)
return
}
c.handleRequestMessage(address, msg)
case shared.MsgPush:
msg := &shared.PushMessage{}
err := json.Unmarshal([]byte(message), msg)
if err != nil {
log.Println("OnMessage: failed to parse JSON!", err)
return
}
c.handlePushMessage(address, msg)
case shared.MsgNotify:
msg := &shared.NotifyMessage{}
err := json.Unmarshal([]byte(message), msg)
if err != nil {
log.Println("OnMessage: failed to parse JSON!", err)
return
}
c.handleNotifyMessage(address, msg)
default:
log.Println("OnMessage: WARNING: Unknown object received:", msgType.String())
}
// in any case return as we are done handling them
return
}
// if unmarshal didn't work check for plain commands:
// TODO these are temporary until it works, remove them later
switch message {
case "push":
log.Println("Sending example push message.")
pm := shared.CreatePushMessage("ID_HERE", shared.OtObject)
c.enc.channel.Send(address, pm.JSON())
case "lock":
log.Println("Sending example lock message.")
lm := shared.CreateLockMessage(shared.LoRequest)
c.enc.channel.Send(address, lm.JSON())
case "unlock":
log.Println("Sending example unlock message.")
lm := shared.CreateLockMessage(shared.LoRelease)
c.enc.channel.Send(address, lm.JSON())
case "request":
log.Println("Sending example request message.")
rm := shared.CreateRequestMessage(shared.OtObject, "ID_HERE")
c.enc.channel.Send(address, rm.JSON())
default:
log.Println("Received:", message)
c.enc.channel.Send(address, "Received non JSON message.")
}
}
