/usr/share/gocode/src/github.com/twstrike/otr3/message_events.go is in golang-github-twstrike-otr3-dev 0.0~git20161015.0.744856d-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | package otr3
import "fmt"
// MessageEvent define the events used to indicate the messages that need to be sent
type MessageEvent int
const (
// MessageEventEncryptionRequired is signaled when our policy requires encryption but we are trying to send an unencrypted message.
MessageEventEncryptionRequired MessageEvent = iota
// MessageEventEncryptionError is signaled when an error occured while encrypting a message and the message was not sent.
MessageEventEncryptionError
// MessageEventConnectionEnded is signaled when we are asked to send a message but the peer has ended the private conversation.
// At this point the connection should be closed or refreshed.
MessageEventConnectionEnded
// MessageEventSetupError will be signaled when a private conversation could not be established. The reason for this will be communicated with the attached error instance.
MessageEventSetupError
// MessageEventMessageReflected will be signaled if we received our own OTR messages.
MessageEventMessageReflected
// MessageEventMessageSent is signaled when a message is sent after having been queued
MessageEventMessageSent
// MessageEventMessageResent is signaled when a message is resent
MessageEventMessageResent
// MessageEventReceivedMessageNotInPrivate will be signaled when we receive an encrypted message that we cannot read, because we don't have an established private connection
MessageEventReceivedMessageNotInPrivate
// MessageEventReceivedMessageUnreadable will be signaled when we cannot read the received message.
MessageEventReceivedMessageUnreadable
// MessageEventReceivedMessageMalformed is signaled when we receive a message that contains malformed data.
MessageEventReceivedMessageMalformed
// MessageEventLogHeartbeatReceived is triggered when we received a heartbeat.
MessageEventLogHeartbeatReceived
// MessageEventLogHeartbeatSent is triggered when we have sent a heartbeat.
MessageEventLogHeartbeatSent
// MessageEventReceivedMessageGeneralError will be signaled when we receive an OTR error from the peer.
// The message parameter will be passed, containing the error message
MessageEventReceivedMessageGeneralError
// MessageEventReceivedMessageUnencrypted is triggered when we receive a message that was sent in the clear when it should have been encrypted.
// The actual message received will also be passed.
MessageEventReceivedMessageUnencrypted
// MessageEventReceivedMessageUnrecognized is triggered when we receive an OTR message whose type we cannot recognize
MessageEventReceivedMessageUnrecognized
// MessageEventReceivedMessageForOtherInstance is triggered when we receive and discard a message for another instance
MessageEventReceivedMessageForOtherInstance
)
// MessageEventHandler handles MessageEvents
type MessageEventHandler interface {
// HandleMessageEvent should handle and send the appropriate message(s) to the sender/recipient depending on the message events
HandleMessageEvent(event MessageEvent, message []byte, err error, trace ...interface{})
}
type dynamicMessageEventHandler struct {
eh func(event MessageEvent, message []byte, err error, trace ...interface{})
}
func (d dynamicMessageEventHandler) HandleMessageEvent(event MessageEvent, message []byte, err error, trace ...interface{}) {
d.eh(event, message, err, trace...)
}
func (c *Conversation) messageEvent(e MessageEvent, trace ...interface{}) {
if c.messageEventHandler != nil {
c.messageEventHandler.HandleMessageEvent(e, nil, nil, trace...)
}
}
func (c *Conversation) messageEventWithError(e MessageEvent, err error) {
if c.messageEventHandler != nil {
c.messageEventHandler.HandleMessageEvent(e, nil, err)
}
}
func (c *Conversation) messageEventWithMessage(e MessageEvent, msg []byte) {
if c.messageEventHandler != nil {
c.messageEventHandler.HandleMessageEvent(e, msg, nil)
}
}
// String returns the string representation of the MessageEvent
func (s MessageEvent) String() string {
switch s {
case MessageEventEncryptionRequired:
return "MessageEventEncryptionRequired"
case MessageEventEncryptionError:
return "MessageEventEncryptionError"
case MessageEventConnectionEnded:
return "MessageEventConnectionEnded"
case MessageEventSetupError:
return "MessageEventSetupError"
case MessageEventMessageReflected:
return "MessageEventMessageReflected"
case MessageEventMessageSent:
return "MessageEventMessageSent"
case MessageEventMessageResent:
return "MessageEventMessageResent"
case MessageEventReceivedMessageNotInPrivate:
return "MessageEventReceivedMessageNotInPrivate"
case MessageEventReceivedMessageUnreadable:
return "MessageEventReceivedMessageUnreadable"
case MessageEventReceivedMessageMalformed:
return "MessageEventReceivedMessageMalformed"
case MessageEventLogHeartbeatReceived:
return "MessageEventLogHeartbeatReceived"
case MessageEventLogHeartbeatSent:
return "MessageEventLogHeartbeatSent"
case MessageEventReceivedMessageGeneralError:
return "MessageEventReceivedMessageGeneralError"
case MessageEventReceivedMessageUnencrypted:
return "MessageEventReceivedMessageUnencrypted"
case MessageEventReceivedMessageUnrecognized:
return "MessageEventReceivedMessageUnrecognized"
case MessageEventReceivedMessageForOtherInstance:
return "MessageEventReceivedMessageForOtherInstance"
default:
return "MESSAGE EVENT: (THIS SHOULD NEVER HAPPEN)"
}
}
type combinedMessageEventHandler struct {
handlers []MessageEventHandler
}
func (c combinedMessageEventHandler) HandleMessageEvent(event MessageEvent, message []byte, err error, trace ...interface{}) {
for _, h := range c.handlers {
if h != nil {
h.HandleMessageEvent(event, message, err, trace...)
}
}
}
// CombineMessageEventHandlers creates a MessageEventHandler that will call all handlers
// given to this function. It ignores nil entries.
func CombineMessageEventHandlers(handlers ...MessageEventHandler) MessageEventHandler {
return combinedMessageEventHandler{handlers}
}
// DebugMessageEventHandler is a MessageEventHandler that dumps all MessageEvents to standard error
type DebugMessageEventHandler struct{}
// HandleMessageEvent dumps all message events
func (DebugMessageEventHandler) HandleMessageEvent(event MessageEvent, message []byte, err error, trace ...interface{}) {
fmt.Fprintf(standardErrorOutput, "%sHandleMessageEvent(%s, message: %#v, error: %v, trace: %v)\n", debugPrefix, event, string(message), err, trace)
}
|