go-xmpp2: comparison stream.go

equal deleted inserted replaced

-:5d721a565503
+:872e936f9f3f
 			if errno, ok := err.(*net.OpError); ok {
 				if errno.Timeout() {
 					continue
 				}
 			}
-			Warnf("read: %s", err)
+			Warn.Logf("read: %s", err)
 			break
 		}
 		nw, err := w.Write(p[:nr])
 		if nw < nr {
-			Warnf("read: %s", err)
+			Warn.Logf("read: %s", err)
 			break
 		}
 	}
 }
 	defer cl.socket.Close()
 	p := make([]byte, 1024)
 	for {
 		nr, err := r.Read(p)
 		if nr == 0 {
-			Warnf("write: %s", err)
+			Warn.Logf("write: %s", err)
 			break
 		}
 		nw, err := cl.socket.Write(p[:nr])
 		if nw < nr {
-			Warnf("write: %s", err)
+			Warn.Logf("write: %s", err)
 			break
 		}
 	}
 }
 func readXml(r io.Reader, ch chan<- interface{},
 extStanza map[string]func(*xml.Name) interface{}) {
-	if Debug != nil {
+	if _, ok := Debug.(*noLog) ; ok {
 		pr, pw := io.Pipe()
 		go tee(r, pw, "S: ")
 		r = pr
 	}
 	defer close(ch)
 	for {
 		// Sniff the next token on the stream.
 		t, err := p.Token()
 		if t == nil {
 			if err != io.EOF {
-				Warnf("read: %s", err)
+				Warn.Logf("read: %s", err)
 			}
 			break
 		}
 		var se xml.StartElement
 		var ok bool
 		var obj interface{}
 		switch se.Name.Space + " " + se.Name.Local {
 		case NsStream + " stream":
 			st, err := parseStream(se)
 			if err != nil {
-				Warnf("unmarshal stream: %s", err)
+				Warn.Logf("unmarshal stream: %s", err)
 				break Loop
 			}
 			ch <- st
 			continue
 		case "stream error", NsStream + " error":
 			obj = &Message{}
 		case NsClient + " presence":
 			obj = &Presence{}
 		default:
 			obj = &Generic{}
-			Infof("Ignoring unrecognized: %s %s", se.Name.Space,
+			Info.Logf("Ignoring unrecognized: %s %s", se.Name.Space,
 				se.Name.Local)
 		}
 		// Read the complete XML stanza.
 		err = p.DecodeElement(obj, &se)
 		if err != nil {
-			Warnf("unmarshal: %s", err)
+			Warn.Logf("unmarshal: %s", err)
 			break Loop
 		}
 		// 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 {
 			err = parseExtended(st, extStanza)
 			if err != nil {
-				Warnf("ext unmarshal: %s", err)
+				Warn.Logf("ext unmarshal: %s", err)
 				break Loop
 			}
 		}
 		// Put it on the channel.
 	return nil
 }
 func writeXml(w io.Writer, ch <-chan interface{}) {
-	if Debug != nil {
+	if _, ok := Debug.(*noLog) ; ok {
 		pr, pw := io.Pipe()
 		go tee(pr, w, "C: ")
 		w = pw
 	}
 	defer func(w io.Writer) {
 	for obj := range ch {
 		if st, ok := obj.(*stream); ok {
 			_, err := w.Write([]byte(st.String()))
 			if err != nil {
-				Warnf("write: %s", err)
+				Warn.Logf("write: %s", err)
 			}
 		} else {
 			err := enc.Encode(obj)
 			if err != nil {
-				Warnf("marshal: %s", err)
+				Warn.Logf("marshal: %s", err)
 				break
 			}
 		}
 	}
 }
 			if !send {
 				continue
 			}
 			st, ok := x.(Stanza)
 			if !ok {
-				Warnf("Unhandled non-stanza: %v", x)
+				Warn.Logf("Unhandled non-stanza: %v", x)
 				continue
 			}
 			if handlers[st.GetId()] != nil {
 				f := handlers[st.GetId()]
 				delete(handlers, st.GetId())
 		case x, ok := <-input:
 			if !ok {
 				break Loop
 			}
 			if x == nil {
-				Infof("Refusing to send nil stanza")
+				Info.Logf("Refusing to send nil stanza")
 				continue
 			}
 			srvOut <- x
 		}
 	}
 Loop:
 	for {
 		select {
 		case newFilterOut := <-filterOut:
 			if newFilterOut == nil {
-				Warnf("Received nil filter")
+				Warn.Logf("Received nil filter")
 				filterIn <- nil
 				continue
 			}
 			filterIn <- topFilter
 			topFilter = newFilterOut
 func handleStream(ss *stream) {
 }
 func (cl *Client) handleStreamError(se *streamError) {
-	Infof("Received stream error: %v", se)
+	Info.Logf("Received stream error: %v", se)
 	close(cl.Out)
 }
 func (cl *Client) handleFeatures(fe *Features) {
 	cl.Features = fe
 	// for it to signal that it's working again.
 	cl.socketSync.Add(1)
 	cl.socket = tls
 	cl.socketSync.Wait()
-	Infof("TLS negotiation succeeded.")
+	Info.Logf("TLS negotiation succeeded.")
 	cl.Features = nil
 	// Now re-send the initial handshake message to start the new
 	// session.
 	hsOut := &stream{To: cl.Jid.Domain, Version: Version}
 	switch strings.ToLower(srv.XMLName.Local) {
 	case "challenge":
 		b64 := base64.StdEncoding
 		str, err := b64.DecodeString(srv.Chardata)
 		if err != nil {
-			Warnf("SASL challenge decode: %s", err)
+			Warn.Logf("SASL challenge decode: %s", err)
 			return
 		}
 		srvMap := parseSasl(string(str))
 		if cl.saslExpected == "" {
 			cl.saslDigest1(srvMap)
 		} else {
 			cl.saslDigest2(srvMap)
 		}
 	case "failure":
-		Infof("SASL authentication failed")
+		Info.Logf("SASL authentication failed")
 	case "success":
-		Infof("Sasl authentication succeeded")
+		Info.Logf("Sasl authentication succeeded")
 		cl.Features = nil
 		ss := &stream{To: cl.Jid.Domain, Version: Version}
 		cl.xmlOut <- ss
 	}
 }
 		if qop == "auth" {
 			hasAuth = true
 		}
 	}
 	if !hasAuth {
-		Warnf("Server doesn't support SASL auth")
+		Warn.Logf("Server doesn't support SASL auth")
 		return
 	}
 	// Pick a realm.
 	var realm string
 	// Generate our own nonce from random data.
 	randSize := big.NewInt(0)
 	randSize.Lsh(big.NewInt(1), 64)
 	cnonce, err := rand.Int(rand.Reader, randSize)
 	if err != nil {
-		Warnf("SASL rand: %s", err)
+		Warn.Logf("SASL rand: %s", err)
 		return
 	}
 	cnonceStr := fmt.Sprintf("%016x", cnonce)
 	/* Now encode the actual password response, as well as the
 	}
 	msg := &Iq{Type: "set", Id: <-Id, Nested: []interface{}{bindReq}}
 	f := func(st Stanza) bool {
 		iq, ok := st.(*Iq)
 		if !ok {
-			Warnf("non-iq response")
+			Warn.Logf("non-iq response")
 		}
 		if iq.Type == "error" {
-			Warnf("Resource binding failed")
+			Warn.Logf("Resource binding failed")
 			return false
 		}
 		var bindRepl *bindIq
 		for _, ele := range iq.Nested {
 			if b, ok := ele.(*bindIq); ok {
 				bindRepl = b
 				break
 			}
 		}
 		if bindRepl == nil {
-			Warnf("Bad bind reply: %v", iq)
+			Warn.Logf("Bad bind reply: %v", iq)
 			return false
 		}
 		jidStr := bindRepl.Jid
 		if jidStr == nil || *jidStr == "" {
-			Warnf("Can't bind empty resource")
+			Warn.Logf("Can't bind empty resource")
 			return false
 		}
 		jid := new(JID)
 		if err := jid.Set(*jidStr); err != nil {
-			Warnf("Can't parse JID %s: %s", *jidStr, err)
+			Warn.Logf("Can't parse JID %s: %s", *jidStr, err)
 			return false
 		}
 		cl.Jid = *jid
-		Infof("Bound resource: %s", cl.Jid.String())
+		Info.Logf("Bound resource: %s", cl.Jid.String())
 		cl.bindDone()
 		return false
 	}
 	cl.HandleStanza(msg.Id, f)
 	cl.xmlOut <- msg

changeset 102	872e936f9f3f
parent 100	24231ff0016c
child 104	99e03b33b20d