go-xmpp2: comparison stream.go

equal deleted inserted replaced

-:578c2a83dc18
+:53f15893a1a7
 		if cl.socket == nil {
 			cl.waitForSocket()
 		}
 		nr, err := cl.socket.Read(p)
 		if nr == 0 {
-			if errno, ok := err.(*net.OpError) ; ok {
+			if errno, ok := err.(*net.OpError); ok {
 				if errno.Timeout() {
 					continue
 				}
 			}
 			if Log != nil {
 		}
 	}
 }
 func readXml(r io.Reader, ch chan<- interface{},
-	extStanza map[string] func(*xml.Name) interface{}) {
+extStanza map[string]func(*xml.Name) interface{}) {
 	if Loglevel >= syslog.LOG_DEBUG {
 		pr, pw := io.Pipe()
 		go tee(r, pw, "S: ")
 		r = pr
 	}
 			}
 			break
 		}
 		var se xml.StartElement
 		var ok bool
-		if se, ok = t.(xml.StartElement) ; !ok {
+		if se, ok = t.(xml.StartElement); !ok {
 			continue
 		}
 		// Allocate the appropriate structure for this token.
 		var obj interface{}
 		}
 		// 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, ok := obj.(Stanza); ok {
 			err = parseExtended(st, extStanza)
 			if err != nil {
 				if Log != nil {
 					Log.Err("ext unmarshal: " +
 						err.String())
 		// Put it on the channel.
 		ch <- obj
 	}
 }
-func parseExtended(st Stanza, extStanza map[string] func(*xml.Name) interface{}) os.Error {
+func parseExtended(st Stanza, extStanza map[string]func(*xml.Name) interface{}) os.Error {
 	// Now parse the stanza's innerxml to find the string that we
 	// can unmarshal this nested element from.
 	reader := strings.NewReader(st.innerxml())
 	p := xml.NewParser(reader)
 	for {
 			break
 		}
 		if err != nil {
 			return err
 		}
-		if se, ok := t.(xml.StartElement) ; ok {
+		if se, ok := t.(xml.StartElement); ok {
-			if con, ok := extStanza[se.Name.Space] ; ok {
+			if con, ok := extStanza[se.Name.Space]; ok {
 				// Call the indicated constructor.
 				nested := con(&se.Name)
 				// Unmarshal the nested element and
 				// stuff it back into the stanza.
 		pr, pw := io.Pipe()
 		go tee(pr, w, "C: ")
 		w = pw
 	}
 	defer func(w io.Writer) {
-		if c, ok := w.(io.Closer) ; ok {
+		if c, ok := w.(io.Closer); ok {
 			c.Close()
 		}
 	}(w)
 	for obj := range ch {
 }
 func (cl *Client) readStream(srvIn <-chan interface{}, cliOut chan<- Stanza) {
 	defer close(cliOut)
-	handlers := make(map[string] func(Stanza) bool)
+	handlers := make(map[string]func(Stanza) bool)
 Loop:
 	for {
 		select {
-		case h := <- cl.handlers:
+		case h := <-cl.handlers:
 			handlers[h.id] = h.f
-		case x, ok := <- srvIn:
+		case x, ok := <-srvIn:
 			if !ok {
 				break Loop
 			}
 			send := false
 			switch obj := x.(type) {
 // 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,
-	control <-chan int) {
+control <-chan int) {
 	defer close(srvOut)
 	var input <-chan Stanza
 Loop:
 	for {
 		select {
-		case status := <- control:
+		case status := <-control:
 			switch status {
 			case 0:
 				input = nil
 			case 1:
 				input = cliIn
 			case -1:
 				break Loop
 			}
-		case x, ok := <- input:
+		case x, ok := <-input:
 			if !ok {
 				break Loop
 			}
 			if x == nil {
 				if Log != nil {
 }
 // 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,
-	topFilter <-chan Stanza, app chan<- Stanza) {
+topFilter <-chan Stanza, app chan<- Stanza) {
 	defer close(app)
 Loop:
 	for {
 		select {
-		case newFilterOut := <- filterOut:
+		case newFilterOut := <-filterOut:
 			if newFilterOut == nil {
 				if Log != nil {
 					Log.Warning("Received nil filter")
 				}
 				filterIn <- nil
 	}
 }
 func filterBottom(from <-chan Stanza, to chan<- Stanza) {
 	defer close(to)
-	for data := range(from) {
+	for data := range from {
 		to <- data
 	}
 }
 func handleStream(ss *stream) {
 }
 // BUG(cjyar): Doesn't implement TLS/SASL EXTERNAL.
 func (cl *Client) chooseSasl(fe *Features) {
 	var digestMd5 bool
-	for _, m := range(fe.Mechanisms.Mechanism) {
+	for _, m := range fe.Mechanisms.Mechanism {
 		switch strings.ToLower(m) {
 		case "digest-md5":
 			digestMd5 = true
 		}
 	}
 	if digestMd5 {
-		auth := &auth{XMLName: xml.Name{Space: NsSASL, Local:
+		auth := &auth{XMLName: xml.Name{Space: NsSASL, Local: "auth"}, Mechanism: "DIGEST-MD5"}
-				"auth"}, Mechanism: "DIGEST-MD5"}
 		cl.xmlOut <- auth
 	}
 }
 func (cl *Client) handleSasl(srv *auth) {
 		if err != nil {
 			if Log != nil {
 				Log.Err("SASL challenge decode: " +
 					err.String())
 			}
-			return;
+			return
 		}
 		srvMap := parseSasl(string(str))
 		if cl.saslExpected == "" {
 			cl.saslDigest1(srvMap)
 		ss := &stream{To: cl.Jid.Domain, Version: Version}
 		cl.xmlOut <- ss
 	}
 }
-func (cl *Client) saslDigest1(srvMap map[string] string) {
+func (cl *Client) saslDigest1(srvMap map[string]string) {
 	// Make sure it supports qop=auth
 	var hasAuth bool
-	for _, qop := range(strings.Fields(srvMap["qop"])) {
+	for _, qop := range strings.Fields(srvMap["qop"]) {
 		if qop == "auth" {
 			hasAuth = true
 		}
 	}
 	if !hasAuth {
 		if Log != nil {
 			Log.Err("Server doesn't support SASL auth")
 		}
-		return;
+		return
 	}
 	// Pick a realm.
 	var realm string
 	if srvMap["realm"] != "" {
 	clMap := make(map[string]string)
 	clMap["realm"] = `"` + realm + `"`
 	clMap["username"] = `"` + username + `"`
 	clMap["nonce"] = `"` + nonce + `"`
 	clMap["cnonce"] = `"` + cnonceStr + `"`
-	clMap["nc"] =  nonceCountStr
+	clMap["nc"] = nonceCountStr
 	clMap["qop"] = "auth"
 	clMap["digest-uri"] = `"` + digestUri + `"`
 	clMap["response"] = response
 	if srvMap["charset"] == "utf-8" {
 		clMap["charset"] = "utf-8"
 	}
 	// Encode the map and send it.
 	clStr := packSasl(clMap)
 	b64 := base64.StdEncoding
-	clObj := &auth{XMLName: xml.Name{Space: NsSASL, Local:
+	clObj := &auth{XMLName: xml.Name{Space: NsSASL, Local: "response"}, Chardata: b64.EncodeToString([]byte(clStr))}
-			"response"}, Chardata:
-		b64.EncodeToString([]byte(clStr))}
 	cl.xmlOut <- clObj
 }
-func (cl *Client) saslDigest2(srvMap map[string] string) {
+func (cl *Client) saslDigest2(srvMap map[string]string) {
 	if cl.saslExpected == srvMap["rspauth"] {
-		clObj := &auth{XMLName: xml.Name{Space: NsSASL, Local:
+		clObj := &auth{XMLName: xml.Name{Space: NsSASL, Local: "response"}}
-				"response"}}
 		cl.xmlOut <- clObj
 	} else {
-		clObj := &auth{XMLName: xml.Name{Space: NsSASL, Local:
+		clObj := &auth{XMLName: xml.Name{Space: NsSASL, Local: "failure"}, Any: &Generic{XMLName: xml.Name{Space: NsSASL,
-				"failure"}, Any:
+			Local: "abort"}}}
-			&Generic{XMLName: xml.Name{Space: NsSASL,
-				Local: "abort"}}}
 		cl.xmlOut <- clObj
 	}
 }
 // Takes a string like `key1=value1,key2="value2"...` and returns a
 // key/value map.
 func parseSasl(in string) map[string]string {
 	re := regexp.MustCompile(`([^=]+)="?([^",]+)"?,?`)
 	strs := re.FindAllStringSubmatch(in, -1)
 	m := make(map[string]string)
-	for _, pair := range(strs) {
+	for _, pair := range strs {
 		key := strings.ToLower(string(pair[1]))
 		value := string(pair[2])
 		m[key] = value
 	}
 	return m
 }
 // Inverse of parseSasl().
 func packSasl(m map[string]string) string {
 	var terms []string
-	for key, value := range(m) {
+	for key, value := range m {
 		if key == "" || value == "" || value == `""` {
 			continue
 		}
-		terms = append(terms, key + "=" + value)
+		terms = append(terms, key+"="+value)
 	}
 	return strings.Join(terms, ",")
 }
 // Computes the response string for digest authentication.
 func saslDigestResponse(username, realm, passwd, nonce, cnonceStr,
-	authenticate, digestUri, nonceCountStr string) string {
+authenticate, digestUri, nonceCountStr string) string {
 	h := func(text string) []byte {
 		h := md5.New()
 		h.Write([]byte(text))
 		return h.Sum()
 	}
 	}
 	kd := func(secret, data string) []byte {
 		return h(secret + ":" + data)
 	}
-	a1 := string(h(username + ":" + realm + ":" + passwd)) + ":" +
+	a1 := string(h(username+":"+realm+":"+passwd)) + ":" +
 		nonce + ":" + cnonceStr
 	a2 := authenticate + ":" + digestUri
-	response := hex(kd(hex(h(a1)), nonce + ":" +
+	response := hex(kd(hex(h(a1)), nonce+":"+
-		nonceCountStr + ":" + cnonceStr + ":auth:" +
+		nonceCountStr+":"+cnonceStr+":auth:"+
 		hex(h(a2))))
 	return response
 }
 // Send a request to bind a resource. RFC 3920, section 7.
 	res := cl.Jid.Resource
 	bindReq := &bindIq{}
 	if res != "" {
 		bindReq.Resource = &res
 	}
-	msg := &Iq{Type: "set", Id: <- Id, Nested: []interface{}{bindReq}}
+	msg := &Iq{Type: "set", Id: <-Id, Nested: []interface{}{bindReq}}
 	f := func(st Stanza) bool {
 		if st.GetType() == "error" {
 			if Log != nil {
 				Log.Err("Resource binding failed")
 			}
 			return false
 		}
 		var bindRepl *bindIq
-		for _, ele := range(st.GetNested()) {
+		for _, ele := range st.GetNested() {
-			if b, ok := ele.(*bindIq) ; ok {
+			if b, ok := ele.(*bindIq); ok {
 				bindRepl = b
 				break
 			}
 		}
 		if bindRepl == nil {

changeset 72	53f15893a1a7
parent 66	4558994ab3b3
child 74	e619e18dcec3
child 98	c9cc4eda6dce