go-xmpp2: comparison stream.go

equal deleted inserted replaced

-:3887d7ad19c1
+:7696e6a01709
 // Callback to handle a stanza with a particular id.
 type stanzaHandler struct {
 	id string
 	// Return true means pass this to the application
-	f func(Stanza) bool
+	f func(interface{}) bool
 }
 // BUG(cjyar) Review all these *Client receiver methods. They should
 // probably either all be receivers, or none.
 		}
 		// If it's a Stanza, we try to unmarshal its innerxml
 		// into objects of the appropriate respective
 		// types. This is specified by our extensions.
-		if st, ok := obj.(Stanza); ok {
+		if st := getStanza(obj) ; st != nil {
 			err = parseExtended(st, extStanza)
 			if err != nil {
 				Warn.Logf("ext unmarshal: %s", err)
 				break Loop
 			}
 		// Put it on the channel.
 		ch <- obj
 	}
 }
-func parseExtended(st Stanza, extStanza map[string]func(*xml.Name) interface{}) error {
+func parseExtended(st *Stanza, extStanza map[string]func(*xml.Name) interface{}) error {
 	// Now parse the stanza's innerxml to find the string that we
 	// can unmarshal this nested element from.
-	reader := strings.NewReader(st.innerxml())
+	reader := strings.NewReader(st.Innerxml)
 	p := xml.NewDecoder(reader)
 	for {
 		t, err := p.Token()
 		if err == io.EOF {
 			break
 				// stuff it back into the stanza.
 				err := p.DecodeElement(nested, &se)
 				if err != nil {
 					return err
 				}
-				st.addNested(nested)
+				st.Nested = append(st.Nested, nested)
 			}
 		}
 	}
 	return nil
 			}
 		}
 	}
 }
-func (cl *Client) readStream(srvIn <-chan interface{}, cliOut chan<- Stanza) {
+func (cl *Client) readStream(srvIn <-chan interface{}, cliOut chan<- interface{}) {
 	defer close(cliOut)
-	handlers := make(map[string]func(Stanza) bool)
+	handlers := make(map[string]func(interface{}) bool)
 Loop:
 	for {
 		select {
 		case h := <-cl.handlers:
 			handlers[h.id] = h.f
 		case x, ok := <-srvIn:
 			if !ok {
 				break Loop
 			}
-			send := false
+			var st *Stanza
 			switch obj := x.(type) {
 			case *stream:
 				handleStream(obj)
 			case *streamError:
 				cl.handleStreamError(obj)
 				cl.handleFeatures(obj)
 			case *starttls:
 				cl.handleTls(obj)
 			case *auth:
 				cl.handleSasl(obj)
+			case *Iq, *Message, *Presence:
+				st = getStanza(obj)
 			default:
-				send = true
+				Warn.Logf("Unhandled non-stanza: %T %#v", x, x)
 			}
-			if !send {
+			if st == nil {
 				continue
 			}
-			st, ok := x.(Stanza)
-			if !ok {
+			send := true
-				Warn.Logf("Unhandled non-stanza: %v", x)
+			if handlers[st.Id] != nil {
-				continue
+				f := handlers[st.Id]
-			}
+				delete(handlers, st.Id)
-			if handlers[st.GetId()] != nil {
+				send = f(x)
-				f := handlers[st.GetId()]
-				delete(handlers, st.GetId())
-				send = f(st)
 			}
 			if send {
-				cliOut <- st
+				cliOut <- x
 			}
 		}
 	}
 }
 // This loop is paused until resource binding is complete. Otherwise
 // the app might inject something inappropriate into our negotiations
 // with the server. The control channel controls this loop's
 // activity.
-func writeStream(srvOut chan<- interface{}, cliIn <-chan Stanza,
+func writeStream(srvOut chan<- interface{}, cliIn <-chan interface{},
 control <-chan int) {
 	defer close(srvOut)
-	var input <-chan Stanza
+	var input <-chan interface{}
 Loop:
 	for {
 		select {
 		case status := <-control:
 			switch status {
 	}
 }
 // Stanzas from the remote go up through a stack of filters to the
 // app. This function manages the filters.
-func filterTop(filterOut <-chan <-chan Stanza, filterIn chan<- <-chan Stanza,
+func filterTop(filterOut <-chan <-chan interface{}, filterIn chan<- <-chan interface{},
-topFilter <-chan Stanza, app chan<- Stanza) {
+topFilter <-chan interface{}, app chan<- interface{}) {
 	defer close(app)
 Loop:
 	for {
 		select {
 		case newFilterOut := <-filterOut:
 			app <- data
 		}
 	}
 }
-func filterBottom(from <-chan Stanza, to chan<- Stanza) {
+func filterBottom(from <-chan interface{}, to chan<- interface{}) {
 	defer close(to)
 	for data := range from {
 		to <- data
 	}
 }
 	res := cl.Jid.Resource
 	bindReq := &bindIq{}
 	if res != "" {
 		bindReq.Resource = &res
 	}
-	msg := &Iq{Type: "set", Id: <-Id, Nested: []interface{}{bindReq}}
+	msg := &Iq{Stanza: Stanza{Type: "set", Id: <-Id,
-	f := func(st Stanza) bool {
+		Nested: []interface{}{bindReq}}}
+	f := func(st interface{}) bool {
 		iq, ok := st.(*Iq)
 		if !ok {
 			Warn.Log("non-iq response")
 		}
 		if iq.Type == "error" {
 				bindRepl = b
 				break
 			}
 		}
 		if bindRepl == nil {
-			Warn.Logf("Bad bind reply: %v", iq)
+			Warn.Logf("Bad bind reply: %#v", iq)
 			return false
 		}
 		jidStr := bindRepl.Jid
 		if jidStr == nil || *jidStr == "" {
 			Warn.Log("Can't bind empty resource")
 // presence) with a given id. The provided function will not be called
 // more than once. If it returns false, the stanza will not be made
 // available on the normal Client.In channel. The stanza handler
 // must not read from that channel, as deliveries on it cannot proceed
 // until the handler returns true or false.
-func (cl *Client) HandleStanza(id string, f func(Stanza) bool) {
+func (cl *Client) HandleStanza(id string, f func(interface{}) bool) {
 	h := &stanzaHandler{id: id, f: f}
 	cl.handlers <- h
 }

changeset 110	7696e6a01709
parent 105	aa895dfae3f6
child 111	36287f2cf06e