libnmdc/src/libnmdc/libnmdc.go

// libnmdc project libnmdc.go
package libnmdc

import (
	"crypto/tls"
	"fmt"
	"net"
	"net/url"
	"regexp"
	"strings"
	"time"
)

type ConnectionState int
type HubEventType int

type HubAddress string

func (this *HubAddress) parse() url.URL {
	parsed, err := url.Parse(strings.ToLower(string(*this)))
	if err != nil || len(parsed.Host) == 0 {
		parsed = &url.URL{
			Scheme: "nmdc",
			Host:   string(*this),
		}
	}

	// Add default port if not specified
	if !strings.ContainsRune(parsed.Host, ':') {
		parsed.Host = parsed.Host + ":411"
	}

	return *parsed
}

func (this *HubAddress) IsSecure() bool {
	parsed := this.parse()

	return parsed.Scheme == "nmdcs" || parsed.Scheme == "dchubs"
}

func (this *HubAddress) GetHostOnly() string {
	return this.parse().Host
}

const (
	CONNECTIONSTATE_DISCONNECTED = 1
	CONNECTIONSTATE_CONNECTING   = 2 // Handshake in progress
	CONNECTIONSTATE_CONNECTED    = 3
)

const (
	EVENT_PUBLIC                   = 1
	EVENT_PRIVATE                  = 2
	EVENT_SYSTEM_MESSAGE_FROM_HUB  = 3
	EVENT_SYSTEM_MESSAGE_FROM_CONN = 4
	EVENT_USER_JOINED              = 5
	EVENT_USER_PART                = 6
	EVENT_USER_UPDATED_INFO        = 7
	EVENT_CONNECTION_STATE_CHANGED = 8
	EVENT_HUBNAME_CHANGED          = 9
	EVENT_DEBUG_MESSAGE            = 10
)

var rx_protocolMessage *regexp.Regexp
var rx_publicChat *regexp.Regexp
var rx_incomingTo *regexp.Regexp

func init() {
	rx_protocolMessage = regexp.MustCompile("(?ms)^[^|]*|")
	rx_publicChat = regexp.MustCompile("(?ms)^<([^>]*)> (.*)$")
	rx_incomingTo = regexp.MustCompile("(?ms)^([^ ]+) From: ([^ ]+) \\$<([^>]*)> (.*)")
}

type HubConnectionOptions struct {
	Address           HubAddress
	Self              UserInfo
	NickPassword      string
	NumEventsToBuffer uint
}

type HubConnection struct {
	// Supplied parameters
	Hco *HubConnectionOptions

	// Current remote status
	HubName string
	State   ConnectionState
	Users   map[string]UserInfo

	// Streamed events
	OnEvent chan HubEvent

	// Private state
	conn         net.Conn
	sentOurHello bool
}

type HubEvent struct {
	EventType   HubEventType
	Nick        string
	Message     string
	StateChange ConnectionState
}

func (cs ConnectionState) Format() string {
	switch cs {
	case CONNECTIONSTATE_DISCONNECTED:
		return "Disconnected"
	case CONNECTIONSTATE_CONNECTING:
		return "Connecting"
	case CONNECTIONSTATE_CONNECTED:
		return "Connected"
	default:
		return "?"
	}
}

func NMDCUnescape(encoded string) string {
	v1 := strings.Replace(encoded, "&#36;", "$", -1)
	v2 := strings.Replace(v1, "&#124;", "|", -1)
	return strings.Replace(v2, "&amp;", "&", -1)
}

func NMDCEscape(plaintext string) string {
	v1 := strings.Replace(plaintext, "&", "&amp;", -1)
	v2 := strings.Replace(v1, "|", "&#124;", -1)
	return strings.Replace(v2, "$", "&#36;", -1)
}

func (this *HubConnection) SayPublic(message string) {
	this.SayRaw("<" + this.Hco.Self.Nick + "> " + NMDCEscape(message) + "|")
}

func (this *HubConnection) SayPrivate(recipient string, message string) {
	this.SayRaw("$To: " + recipient + " From: " + this.Hco.Self.Nick + " $<" + this.Hco.Self.Nick + "> " + NMDCEscape(message) + "|")
}

func (this *HubConnection) SayInfo() {
	this.SayRaw(this.Hco.Self.toMyINFO() + "|")
}

func (this *HubConnection) userJoined_NameOnly(nick string) {
	_, already_existed := this.Users[nick]
	if !already_existed {
		this.Users[nick] = *NewUserInfo(nick)
		this.OnEvent <- HubEvent{EventType: EVENT_USER_JOINED, Nick: nick}
	}
}

func (this *HubConnection) userJoined_Full(uinf *UserInfo) {
	_, already_existed := this.Users[uinf.Nick]
	if !already_existed {
		this.Users[uinf.Nick] = *uinf
		this.OnEvent <- HubEvent{EventType: EVENT_USER_JOINED, Nick: uinf.Nick}
	}
}

// Note that protocol messages are transmitted on the caller thread, not from
// any internal libnmdc thread.
func (this *HubConnection) SayRaw(protocolCommand string) error {
	_, err := this.conn.Write([]byte(protocolCommand))
	return err
}

func parseLock(lock []byte) string {

	nibble_swap := func(b byte) byte {
		return ((b << 4) & 0xF0) | ((b >> 4) & 0x0F)
	}

	chr := func(b byte) string {
		if b == 0 || b == 5 || b == 36 || b == 96 || b == 124 || b == 126 {
			return fmt.Sprintf("/%%DCN%04d%%/", b)
		} else {
			return string(b)
		}
	}

	key := chr(nibble_swap(lock[0] ^ lock[len(lock)-2] ^ lock[len(lock)-3] ^ 5))
	for i := 1; i < len(lock); i += 1 {
		key += chr(nibble_swap(lock[i] ^ lock[i-1]))
	}

	return key
}

func (this *HubConnection) processProtocolMessage(message string) {

	// Zero-length protocol message
	// ````````````````````````````
	if len(message) == 0 {
		return
	}

	// Public chat
	// ```````````
	if rx_publicChat.MatchString(message) {
		pubchat_parts := rx_publicChat.FindStringSubmatch(message)
		this.OnEvent <- HubEvent{EventType: EVENT_PUBLIC, Nick: pubchat_parts[1], Message: NMDCUnescape(pubchat_parts[2])}
		return
	}

	// System messages
	// ```````````````
	if message[0] != '$' {
		this.OnEvent <- HubEvent{EventType: EVENT_SYSTEM_MESSAGE_FROM_HUB, Nick: this.HubName, Message: NMDCUnescape(message)}
		return
	}

	// Protocol messages
	// `````````````````

	commandParts := strings.SplitN(message, " ", 2)
	switch commandParts[0] {

	case "$Lock":
		this.SayRaw("$Supports NoGetINFO UserCommand UserIP2|" +
			"$Key " + parseLock([]byte(commandParts[1])) + "|" +
			"$ValidateNick " + NMDCEscape(this.Hco.Self.Nick) + "|")
		this.sentOurHello = false

	case "$Hello":
		if commandParts[1] == this.Hco.Self.Nick && !this.sentOurHello {
			this.SayRaw("$Version 1,0091|")
			this.SayRaw("$GetNickList|")
			this.SayInfo()
			this.sentOurHello = true

		} else {
			this.userJoined_NameOnly(commandParts[1])

		}

	case "$HubName":
		this.HubName = commandParts[1]
		this.OnEvent <- HubEvent{EventType: EVENT_HUBNAME_CHANGED, Nick: commandParts[1]}

	case "$ValidateDenide": // sic
		if len(this.Hco.NickPassword) > 0 {
			this.OnEvent <- HubEvent{EventType: EVENT_SYSTEM_MESSAGE_FROM_CONN, Message: "Incorrect password."}
		} else {
			this.OnEvent <- HubEvent{EventType: EVENT_SYSTEM_MESSAGE_FROM_CONN, Message: "Nick already in use."}
		}

	case "$HubIsFull":
		this.OnEvent <- HubEvent{EventType: EVENT_SYSTEM_MESSAGE_FROM_CONN, Message: "Hub is full."}

	case "$BadPass":
		this.OnEvent <- HubEvent{EventType: EVENT_SYSTEM_MESSAGE_FROM_CONN, Message: "Incorrect password."}

	case "$GetPass":
		this.SayRaw("$MyPass " + NMDCEscape(this.Hco.NickPassword) + "|")

	case "$Quit":
		delete(this.Users, commandParts[1])
		this.OnEvent <- HubEvent{EventType: EVENT_USER_PART, Nick: commandParts[1]}

	case "$MyINFO":
		u := UserInfo{}
		err := u.fromMyINFO(commandParts[1])
		if err == nil {
			this.userJoined_Full(&u)
		} else {
			this.OnEvent <- HubEvent{EventType: EVENT_DEBUG_MESSAGE, Message: err.Error()}
		}

	case "$NickList":
		nicklist := strings.Split(commandParts[1], "$$")
		for _, nick := range nicklist {
			if len(nick) > 0 {
				this.userJoined_NameOnly(nick)
			}
		}

	case "$To:":
		valid := false
		if rx_incomingTo.MatchString(commandParts[1]) {
			txparts := rx_incomingTo.FindStringSubmatch(commandParts[1])
			if txparts[1] == this.Hco.Self.Nick && txparts[2] == txparts[3] {
				this.OnEvent <- HubEvent{EventType: EVENT_PRIVATE, Nick: txparts[2], Message: txparts[4]}
				valid = true
			}
		}

		if !valid {
			this.OnEvent <- HubEvent{EventType: EVENT_DEBUG_MESSAGE, Message: "Malformed private message '" + commandParts[1] + "'"}
		}

	case "$UserIP":
		// Final message in PtokaX connection handshake - trigger connection callback.
		// This might not be the case for other hubsofts, though
		if this.State != CONNECTIONSTATE_CONNECTED {
			this.OnEvent <- HubEvent{EventType: EVENT_CONNECTION_STATE_CHANGED, StateChange: CONNECTIONSTATE_CONNECTED}
			this.State = CONNECTIONSTATE_CONNECTED
		}

	case "$UserCommand":
		// TODO

	case "$ForceMove":
		// TODO

	// IGNORABLE COMMANDS
	case "$Supports":
	case "$UserList":
	case "$OpList":
	case "$HubTopic":
	case "$Search":
	case "$ConnectToMe":

	default:
		this.OnEvent <- HubEvent{EventType: EVENT_DEBUG_MESSAGE, Message: "Unhandled protocol command '" + commandParts[0] + "'"}

	}
}

func (this *HubConnection) worker() {
	var fullBuffer string
	var err error = nil
	var nbytes int = 0

	for {

		// If we're not connected, attempt reconnect
		if this.conn == nil {

			if this.Hco.Address.IsSecure() {
				this.conn, err = tls.Dial("tcp", this.Hco.Address.GetHostOnly(), nil)
			} else {
				this.conn, err = net.Dial("tcp", this.Hco.Address.GetHostOnly())
			}

			if err == nil {
				this.OnEvent <- HubEvent{EventType: EVENT_CONNECTION_STATE_CHANGED, StateChange: CONNECTIONSTATE_CONNECTING}
			}
		}

		// Read from socket into our local buffer (blocking)
		if this.conn != nil {
			readBuff := make([]byte, 4096)
			nbytes, err = this.conn.Read(readBuff)
			if nbytes > 0 {
				fullBuffer += string(readBuff[0:nbytes])
			}
		}

		// Maybe we disconnected
		if err != nil {
			this.OnEvent <- HubEvent{EventType: EVENT_CONNECTION_STATE_CHANGED, StateChange: CONNECTIONSTATE_DISCONNECTED, Message: err.Error()}
			this.conn = nil
			time.Sleep(30 * time.Second) // Wait before reconnect
			continue
		}

		// Attempt to parse a message block
		for len(fullBuffer) > 0 {
			for len(fullBuffer) > 0 && fullBuffer[0] == '|' {
				fullBuffer = fullBuffer[1:]
			}
			protocolMessage := rx_protocolMessage.FindString(fullBuffer)
			if len(protocolMessage) > 0 {
				this.processProtocolMessage(string(protocolMessage))
				fullBuffer = fullBuffer[len(protocolMessage):]
			} else {
				break
			}
		}

	}

}

// Connects to an NMDC server, and spawns a background goroutine to handle
//  protocol messages. Client code should select on all the interface channels.
func (this *HubConnectionOptions) Connect() *HubConnection {

	if this.Self.ClientTag == "" {
		this.Self.ClientTag = "libnmdc.go"
	}
	if this.NumEventsToBuffer < 1 {
		this.NumEventsToBuffer = 1
	}

	hc := HubConnection{
		Hco:          this,
		HubName:      "(unknown)",
		State:        CONNECTIONSTATE_DISCONNECTED,
		Users:        make(map[string]UserInfo),
		OnEvent:      make(chan HubEvent, this.NumEventsToBuffer),
		sentOurHello: false,
	}

	go hc.worker()

	return &hc
}