Merge branch 'element-handling'

This moves away from the concept to parse each individual XML token from
the token and group them as a []xml.Token slice for further processing.

While this is still possible, receiving aswell as sending has switched
to define structs with XML tags which can be marshalled and unmarshalled
with the xml.Encoder.EncodeElement() and xml.Decoder.DecodeElement()
functions.

Further documentation can be found at https://pkg.go.dev/encoding/xml#Unmarshal
and https://pkg.go.dev/encoding/xml#Marshal.

This merge reduces with its changes the number of code lines in the XMPP
implementation by around 41 percent!

1 files changed, 0 insertions, 131 deletions

diff --git a/xmpp/stream_pair.go b/xmpp/stream_pair.go
deleted file mode 100644
index 87df86a..0000000
--- a/xmpp/stream_pair.go
+++ /dev/null
@@ -1,131 +0,0 @@
-package xmpp
-
-import (
-	"encoding/xml"
-	"log"
-)
-
-func runStreamPair(s *session) {
-	end := openStream(s)
-	defer closeStream(s, end)
-
-	buf := newElementBuffer()
-
-	for {
-		select {
-		case data := <-s.in:
-			switch data.(type) {
-			case SessionShouldDisconnect:
-				return
-			default:
-				log.Printf("Unknown data '%d'!\n", data)
-			}
-		case t := <-s.rx:
-			err := buf.add(t)
-			if err != nil {
-				log.Printf("Could not add XML token to buffer: %v\n", err)
-				return
-			}
-			if buf.isComplete() {
-				element := buf.reset()
-				route(s, element, getRoutingTable())
-			}
-		}
-	}
-}
-
-func openStream(s *session) xml.EndElement {
-	start := xml.StartElement{
-		xml.Name{"jabber:client", "stream:stream"},
-		[]xml.Attr{
-			xml.Attr{xml.Name{"", "from"}, s.jid},
-			xml.Attr{xml.Name{"", "to"}, domainpart(s.jid)},
-			xml.Attr{xml.Name{"", "version"}, "1.0"},
-			xml.Attr{xml.Name{"", "xml:lang"}, "en"},
-			xml.Attr{xml.Name{"", "xmlns:stream"}, "http://etherx.jabber.org/streams"},
-		},
-	}
-	end := start.End()
-
-	err := s.ed.encodeToken(start)
-	if err != nil {
-		log.Println("Could not encode stream start!")
-	}
-
-	syncStreams(s)
-
-	return end
-}
-
-// syncStreams drops XML tokens from the receiving stream until an
-// xml.StartElement with the local name `stream` is received. If this function
-// is called after opening a new stream in the sending direction it is ensured
-// that both streams directions work on the same stream level and are in sync.
-// Tokens received which are not a stream StartElement are not handled but
-// logged since this should not happen.
-func syncStreams(s *session) {
-	for {
-		select {
-		case data := <-s.in:
-			switch data.(type) {
-			case SessionShouldDisconnect:
-				return
-			default:
-				log.Printf("Unhandled data '%d' during stream sync!\n", data)
-			}
-		case t := <-s.rx:
-			switch token := t.(type) {
-			case xml.StartElement:
-				if token.Name.Local == "stream" {
-					return
-				}
-			}
-			log.Printf("Unhandled XML token '%v' during stream sync!\n", t)
-		}
-	}
-}
-
-func closeStream(s *session, end xml.EndElement) {
-	err := s.ed.encodeToken(end)
-	if err != nil {
-		log.Println("Could not encode stream end!")
-	}
-}
-
-func streamFeaturesHandler(s *session, e []xml.Token) {
-	if hasSaslPlain(e) {
-		s.sasl()
-		return
-	}
-
-	if hasBind(e) {
-		s.sendBind()
-		return
-	}
-
-	log.Println("Stream has no implemented features!")
-}
-
-func iqHandler(s *session, e []xml.Token) {
-	isResult := false
-	idMatches := false
-
-	result := xml.Attr{xml.Name{"", "type"}, "result"}
-	id := xml.Attr{xml.Name{"", "id"}, s.resourceReq}
-
-	switch start := e[0].(type) {
-	case xml.StartElement:
-		for _, v := range start.Attr {
-			if v == result {
-				isResult = true
-			}
-			if v == id {
-				idMatches = true
-			}
-		}
-
-		if isResult && idMatches {
-			s.sendPresence()
-		}
-	}
-}