Beispiel #1
4
func main() {
	inputReader := strings.NewReader(input)

	decoder := xml.NewDecoder(inputReader)
	for {
		// Read tokens from the XML document in a stream.
		t, _ := decoder.Token()
		if t == nil {
			break
		}
		// Inspect the type of the token just read.
		//fmt.Printf("\n<!--%#v-->\n", t)
		switch x := t.(type) {
		case xml.StartElement:
			fmt.Printf("<%s", x.Name.Local)
			for _, attr := range x.Attr {
				fmt.Printf(" %s=\"", attr.Name.Local)
				xml.EscapeText(os.Stdout, []byte(attr.Value))
				os.Stdout.Write([]byte{'"'})
			}
			fmt.Printf(">")
		case xml.CharData:
			xml.EscapeText(os.Stdout, bytes.TrimSpace(x))
		case xml.EndElement:
			fmt.Printf("</%s>\n", x.Name.Local)
		}

	}
}
Beispiel #2
0
func value_to_xml(v interface{}) (string, error) {
	switch t := v.(type) {
	case int, int8, int64, int32, *int, *int8, *int64, *int32:
		return fmt.Sprintf("<int>%d</int>", t), nil
	case string:
		buf := bytes.NewBuffer(make([]byte, 0))
		err := xml.EscapeText(buf, []byte(t))
		if err != nil {
			return "", err
		}
		return fmt.Sprintf("<string>%s</string>", buf.String()), nil
	case []byte:
		return fmt.Sprintf("<base64>%s</base64>", base64.StdEncoding.EncodeToString(t)), nil
	case float32, float64, *float32, *float64:
		return fmt.Sprintf("<double>%f</double>", t), nil
	case bool:
		return fmt.Sprintf("<boolean>%d</boolean>", btoi(t)), nil
	case time.Time:
		buf := bytes.NewBuffer(make([]byte, 0))
		err := xml.EscapeText(buf, []byte(t.Format(time_ISO8601_FORMAT)))
		if err != nil {
			return "", err
		}
		return fmt.Sprintf("<dateTime.iso8601>%s</dateTime.iso8601>", buf.String()), nil
	case *time.Time:
		buf := bytes.NewBuffer(make([]byte, 0))
		err := xml.EscapeText(buf, []byte(t.Format(time_ISO8601_FORMAT)))
		if err != nil {
			return "", err
		}
		return fmt.Sprintf("<dateTime.iso8601>%s</dateTime.iso8601>", buf.String()), nil
	case []interface{}:
		tmp_str_arr := []string{"<array><data>"}
		for _, v := range t {
			subval, err := value_to_xml(v)
			if err != nil {
				return "", err
			}
			tmp_str_arr = append(tmp_str_arr, fmt.Sprintf("<value>%s</value>", subval))
		}
		tmp_str_arr = append(tmp_str_arr, "</data></array>")
		return strings.Join(tmp_str_arr, ""), nil
	case map[string]interface{}:
		tmp_str_arr := []string{"<struct>"}
		for name, item := range t {
			tmp_str_arr = append(tmp_str_arr, "<member>")
			tmp_str_arr = append(tmp_str_arr, fmt.Sprintf("<name>%s</name>", name))
			subval, err := value_to_xml(item)
			if err != nil {
				return "", err
			}
			tmp_str_arr = append(tmp_str_arr, fmt.Sprintf("<value>%s</value>", subval))
			tmp_str_arr = append(tmp_str_arr, "</member>")
		}
		tmp_str_arr = append(tmp_str_arr, "</struct>")
		return strings.Join(tmp_str_arr, ""), nil
	default:
		return "", errors.New("Unrecognized type")
	}
}
Beispiel #3
0
func encodeDomainCheck(buf *bytes.Buffer, domains []string, extFee bool) error {
	buf.Reset()
	buf.WriteString(xmlCommandPrefix)
	buf.WriteString(`<check>`)
	buf.WriteString(`<domain:check xmlns:domain="urn:ietf:params:xml:ns:domain-1.0">`)
	for _, domain := range domains {
		buf.WriteString(`<domain:name>`)
		xml.EscapeText(buf, []byte(domain))
		buf.WriteString(`</domain:name>`)
	}
	buf.WriteString(`</domain:check>`)
	buf.WriteString(`</check>`)

	if extFee {
		// Extensions
		buf.WriteString(`<extension>`)

		// CentralNic fee extension
		buf.WriteString(`<fee:check xmlns:fee="urn:ietf:params:xml:ns:fee-0.5">`)
		for _, domain := range domains {
			buf.WriteString(`<fee:domain>`)
			buf.WriteString(`<fee:name>`)
			xml.EscapeText(buf, []byte(domain))
			buf.WriteString(`</fee:name>`)
			buf.WriteString(`<fee:command>create</fee:command>`)
			buf.WriteString(`</fee:domain>`)
		}
		buf.WriteString(`</fee:check>`)

		buf.WriteString(`</extension>`)
	}

	buf.WriteString(xmlCommandSuffix)
	return nil
}
Beispiel #4
0
// meh3
func genQuery(query string, args dict) []byte {
	var out bytes.Buffer
	out.WriteString("<query")
	for key, val := range args {
		fmt.Fprintf(&out, " %s=\"", key)
		xml.EscapeText(&out, []byte(val))
		out.WriteString("\"")

	}
	out.WriteString(">")
	xml.EscapeText(&out, []byte(query))
	out.WriteString("</query>\r\n.\r\n")

	return out.Bytes()
}
Beispiel #5
0
// ToXML marshal map[string]string to xmlWriter with xml format, the root node name is xml.
//  NOTE: This function assumes the key of m map[string]string are legitimate xml name string
//  that does not contain the required escape character!
func (x *Xml) ToXML(xmlWriter io.Writer, m map[string]string) (err error) {
	if xmlWriter == nil {
		return errors.New("nil xmlWriter")
	}

	if _, err = io.WriteString(xmlWriter, "<xml>"); err != nil {
		return
	}

	for k, v := range m {
		if _, err = io.WriteString(xmlWriter, "<"+k+">"); err != nil {
			return
		}
		if err = xml.EscapeText(xmlWriter, []byte(v)); err != nil {
			return
		}
		if _, err = io.WriteString(xmlWriter, "</"+k+">"); err != nil {
			return
		}
	}

	if _, err = io.WriteString(xmlWriter, "</xml>"); err != nil {
		return
	}
	return
}
Beispiel #6
0
func (w *Writer) WriteQuad(q quad.Quad) error {
	if w.err != nil {
		return w.err
	}
	if !w.written {
		if _, err := w.w.Write([]byte(header)); err != nil {
			return err
		}
		w.written = true
		w.nodes = make(map[string]int)
	}
	s := w.writeNode(quad.StringOf(q.Subject))
	o := w.writeNode(quad.StringOf(q.Object))
	if w.err != nil {
		return w.err
	}
	_, w.err = fmt.Fprintf(w.w, "\t\t<edge source=\"n%d\" target=\"n%d\"><data key=\"d1\">", s, o)
	if w.err != nil {
		return w.err
	}
	if w.err = xml.EscapeText(w.w, []byte(quad.StringOf(q.Predicate))); w.err != nil {
		return w.err
	}
	_, w.err = w.w.Write([]byte("</data></edge>\n"))
	return w.err
}
Beispiel #7
0
// Return an XML-RPC fault
func writeFault(out io.Writer, code int, msg string) {
	fmt.Fprintf(out, `<?xml version="1.0"?>
<methodResponse>
  <fault>
	<value>
		<struct>
		  <member>
			<name>faultCode</name>
			<value><int>%d</int></value>
		  </member>
		  <member>
			<name>faultString</name>
			<value>`, code)
	err := xml.EscapeText(out, []byte(msg))
	fmt.Fprintf(out, `</value>
		  </member>
		</struct>
	</value>
  </fault>
</methodResponse>`)

	// XXX dump the error to Stderr for now
	if err != nil {
		fmt.Fprintf(os.Stderr, "Cannot write fault#%d(%s): %v\n", code, msg,
			err)
	}
}
Beispiel #8
0
// The HTTP voice processing endpoint reads DTMF (input from Twilio request) and translates it into a statement and execute.
func (sh *WebShell) httpAPIVoiceMessage(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/xml")
	w.Header().Set("Cache-Control", "must-revalidate")
	w.WriteHeader(http.StatusOK)
	digits := r.FormValue("Digits")
	decodedLetters := voiceDecodeDTMF(digits)
	log.Printf("Voice message got digits: %s (decoded - %s)", digits, decodedLetters)
	if cmd := sh.cmdFind(decodedLetters); cmd == "" {
		// PIN mismatch
		w.Write([]byte(`<?xml version="1.0" encoding="UTF-8"?>
<Response>
	<Say>Sorry</Say>
	<Hangup/>
</Response>
`))
	} else {
		// Speak the command result and repeat
		output := sh.cmdRun(cmd, sh.WebTimeoutSec, sh.WebTruncateLen, true, true)
		var escapeOutput bytes.Buffer
		if err := xml.EscapeText(&escapeOutput, []byte(output)); err != nil {
			log.Printf("XML escape failed - %v", err)
		}
		w.Write([]byte(fmt.Sprintf(`<?xml version="1.0" encoding="UTF-8"?>
<Response>
    <Gather action="%s%s" method="POST" timeout="15" finishOnKey="#" numDigits="1000">
        <Say voice="man" loop="1" language="en">%s over</Say>
    </Gather>
</Response>
`, sh.VoiceEndpointPrefix, sh.VoiceProcEndpoint, escapeOutput.String())))
	}
}
Beispiel #9
0
func serializeItem(k string, v interface{}, w io.Writer) {
	w.Write([]byte(`<item key="`))
	xml.EscapeText(w, []byte(k))
	w.Write([]byte(`">`))
	switch i := v.(type) {
	case string:
		xml.EscapeText(w, []byte(i))
	case NestedStringMap:
		serializeMap(i, w)
	case []NestedStringMap:
		serializeNSMArray(i, w)
	case []string:
		serializeStringArray(i, w)
	}
	w.Write([]byte(`</item>`))
}
Beispiel #10
0
func (s *Shell) NewCommand(cmd string, arguments []string) (string, error) {
	var buf = bytes.NewBuffer(make([]byte, 0, len(cmd)))
	if e := xml.EscapeText(buf, []byte(cmd)); nil != e {
		return "", e
	}

	env := &envelope.CreateCommand{Uuid(), s.Id, strings.Replace(buf.String(), "&#34;", "&quot;", -1), arguments}
	reader, err := s.Deliver(bytes.NewBufferString(env.Xml()))
	if err != nil {
		return "", err
	}
	defer closeReader(reader)

	decoder := xml.NewDecoder(reader)

	if err := ReadEnvelopeBody(decoder); nil != err {
		return "", err
	}

	ok, err := locateElements(decoder, []string{"CommandResponse", "CommandId"})
	if nil != err {
		return "", errors.New("locate 'Envelope/Body/CommandResponse/CommandId' failed, " + err.Error())
	}
	if !ok {
		return "", ElementNotExists("Envelope/Body/CommandResponse/CommandId")
	}

	id, e := readXmlText(decoder)
	if nil != e {
		return "", errors.New("read CommandId from the response failed, " + e.Error())
	}

	return id, nil
}
Beispiel #11
0
// 格式化 map[string]string 为 xml 格式
// 用于微信支付
func FormatMapToXML(xmlWriter io.Writer, Map map[string]string) (err error) {
	if xmlWriter == nil {
		return errors.New("xmlWriter == nil")
	}

	_, err = io.WriteString(xmlWriter, "<xml>\n")
	if err != nil {
		return
	}

	for key, value := range Map {
		_, err = io.WriteString(xmlWriter, "<"+key+">")
		if err != nil {
			return
		}
		if err = xml.EscapeText(xmlWriter, []byte(value)); err != nil {
			return
		}
		_, err = io.WriteString(xmlWriter, "</"+key+">\n")
		if err != nil {
			return
		}
	}

	_, err = io.WriteString(xmlWriter, "</xml>")
	if err != nil {
		return
	}

	return
}
Beispiel #12
0
func escapeXml(in string) string {
	var out bytes.Buffer
	err := xml.EscapeText(&out, []byte(in))
	if err != nil {
		panic("Could not escape XML: " + err.Error())
	}
	return out.String()
}
Beispiel #13
0
func (this *Node) printText() []byte {
	val := []byte(this.Value)
	if len(this.Parent.Children) > 1 {
		return val
	}
	var b bytes.Buffer
	xml.EscapeText(&b, val)
	return b.Bytes()
}
Beispiel #14
0
func escapeXml(s string) string {
	buf := new(bytes.Buffer)
	buf.Grow(len(s))
	err := xml.EscapeText(buf, []byte(s))
	if err != nil {
		panic(err)
	}
	return buf.String()
}
Beispiel #15
0
func escapeXmlText(s string) (string, error) {
	buffer := new(bytes.Buffer)
	err := xml.EscapeText(buffer, []byte(s))

	if err != nil {
		return "", err
	}

	return buffer.String(), nil
}
Beispiel #16
0
// encodeRequestAction is a hacky way to create an encoded SOAP envelope
// containing the given action. Experiments with one router have shown that it
// 500s for requests where the outer default xmlns is set to the SOAP
// namespace, and then reassigning the default namespace within that to the
// service namespace. Hand-coding the outer XML to work-around this.
func encodeRequestAction(actionNamespace, actionName string, inAction interface{}) ([]byte, error) {
	requestBuf := new(bytes.Buffer)
	requestBuf.WriteString(soapPrefix)
	requestBuf.WriteString(`<u:`)
	xml.EscapeText(requestBuf, []byte(actionName))
	requestBuf.WriteString(` xmlns:u="`)
	xml.EscapeText(requestBuf, []byte(actionNamespace))
	requestBuf.WriteString(`">`)
	if inAction != nil {
		if err := encodeRequestArgs(requestBuf, inAction); err != nil {
			return nil, err
		}
	}
	requestBuf.WriteString(`</u:`)
	xml.EscapeText(requestBuf, []byte(actionName))
	requestBuf.WriteString(`>`)
	requestBuf.WriteString(soapSuffix)
	return requestBuf.Bytes(), nil
}
Beispiel #17
0
func (p Post) Excerpt() string {
	r := regexp.MustCompile("<p>(.+?)</p>")
	result := r.FindStringSubmatch(p.htmlContent)
	if len(result) > 1 {
		buf := new(bytes.Buffer)
		xml.EscapeText(buf, []byte(result[1]))
		return buf.String() + " ..."
	}
	return ""
}
Beispiel #18
0
// Connect connects and logs in to a vSphere host.
func Connect(host, user, pwd string) (*Vsphere, error) {
	header := http.Header{
		"Content-Type": []string{`text/xml; charset=UTF-8`},
		"SOAPAction":   []string{`"urn:vim25/5.5"`},
	}
	jar, err := cookiejar.New(nil)
	if err != nil {
		return nil, err
	}
	v := &Vsphere{
		url: &url.URL{
			Scheme: "https",
			Host:   host,
			Path:   "/sdk",
		},
		header: header,
		client: &http.Client{
			Timeout: time.Minute,
			Transport: &http.Transport{
				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
			},
		},
		cookies: jar,
	}
	uuid := struct {
		UUID string `xml:"Body>RetrieveServiceContentResponse>returnval>about>instanceUuid"`
	}{}
	if err := v.call(soapConnect, &uuid); err != nil {
		return nil, err
	}
	if uuid.UUID == "" {
		return nil, fmt.Errorf("vsphere: no UUID during connect")
	}
	userbuf := new(bytes.Buffer)
	pwdbuf := new(bytes.Buffer)
	xml.EscapeText(userbuf, []byte(user))
	xml.EscapeText(pwdbuf, []byte(pwd))
	if err := v.call(fmt.Sprintf(soapLogin, userbuf, pwdbuf), nil); err != nil {
		return nil, err
	}
	return v, nil
}
Beispiel #19
0
func escape(s string) string {
	for i := 0; i < len(s); i++ {
		switch s[i] {
		case '"', '&', '\'', '<', '>':
			b := bytes.NewBuffer(nil)
			xml.EscapeText(b, []byte(s))
			return b.String()
		}
	}
	return s
}
Beispiel #20
0
func (res *Resources) SetColor(name, value string) *Resources {
	for index, _ := range res.Colors {
		if name == res.Colors[index].Name {
			m := new(bytes.Buffer)
			xml.EscapeText(m, []byte(value))
			res.Colors[index].Value = m.String()
			break
		}
	}
	return res
}
Beispiel #21
0
func transformContainer(o *bytes.Buffer, cont *namedContainer) error {
	var printName string

	if cont.name != "" {
		escapedNameBuf := bytes.NewBuffer(nil)
		err := xml.EscapeText(escapedNameBuf, []byte(cont.name))
		if err != nil {
			return err
		}
		printName = fmt.Sprintf(" name=\"%s\"", escapedNameBuf.String())
	}

	data := cont.Data()
	switch data.(type) {
	case nil:
		o.WriteString(fmt.Sprintf("<json:null%s />", printName))

	case bool:
		o.WriteString(fmt.Sprintf("<json:boolean%s>%t</json:boolean>", printName, data))

	case json.Number:
		o.WriteString(fmt.Sprintf("<json:number%s>%v</json:number>", printName, data))

	case string:
		o.WriteString(fmt.Sprintf("<json:string%s>%v</json:string>", printName, data))

	case []interface{}:
		o.WriteString(fmt.Sprintf("<json:array%s>", printName))
		arrayChildren, err := cont.Children()
		if err != nil {
			return err
		}
		for _, child := range arrayChildren {
			if err := transformContainer(o, &namedContainer{Container: child}); err != nil {
				return err
			}
		}
		o.WriteString("</json:array>")

	case map[string]interface{}:
		o.WriteString(fmt.Sprintf("<json:object%s>", printName))

		if err := sortAndTransformObject(o, cont); err != nil {
			return err
		}

		o.WriteString("</json:object>")
	}

	return nil
}
Beispiel #22
0
func (xf xfdf) WriteTo(w io.Writer) (int64, error) {
	cew := &countErrWriter{w: w}
	if _, err := io.WriteString(cew, `<?xml version="1.0" encoding="UTF-8"?>
<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">
   <fields>
`); err != nil {
		return cew.n, err
	}

	for _, key := range xf.Fields {
		io.WriteString(cew, `		<field name="`)
		cew.err = xml.EscapeText(cew, []byte(key))
		io.WriteString(cew, `"><value>`)
		cew.err = xml.EscapeText(cew, []byte(""))
		io.WriteString(cew, "</value></field>\n")
		if cew.err != nil {
			return cew.n, cew.err
		}
	}
	io.WriteString(cew, `	</fields>
</xfdf>`)
	return cew.n, cew.err
}
Beispiel #23
0
func xml_addrs(w http.ResponseWriter, r *http.Request) {
	if !ipchecker(r) {
		return
	}

	w.Header()["Content-Type"] = []string{"text/xml"}

	w.Write([]byte("<addrbook>"))
	// Address Book
	book := wallet.LoadWalfile(common.GocoinHomeDir+"wallet/"+wallet.AddrBookFileName, 0)
	for i := range book {
		w.Write([]byte("<entry>"))
		w.Write([]byte("<addr>" + book[i].Enc58str + "</addr>"))
		w.Write([]byte("<label>"))
		xml.EscapeText(w, []byte(book[i].Extra.Label))
		w.Write([]byte("</label>"))
		w.Write([]byte("<wallet>"))
		xml.EscapeText(w, []byte(book[i].Extra.Wallet))
		w.Write([]byte("</wallet>"))
		w.Write([]byte("</entry>"))
	}
	w.Write([]byte("</addrbook>"))
}
Beispiel #24
0
func (x *xmlObj) marshal() []byte {
	b := new(bytes.Buffer)
	for i := 0; i < len(x.xt); i++ {
		switch token := x.xt[i].token.(type) {
		case xml.StartElement:
			if token.Name.Space == "" {
				b.WriteString("<" + token.Name.Local)
			} else {
				b.WriteString("<" + token.Name.Space + ":" + token.Name.Local)
			}
			for _, attr := range token.Attr {
				b.WriteByte(' ')
				if attr.Name.Space == "" {
					b.WriteString(attr.Name.Local + "=\"" + attr.Value + "\"")
				} else {
					b.WriteString(attr.Name.Space + ":" + attr.Name.Local + "=\"" + attr.Value + "\"")
				}
			}
			b.WriteByte('>')
		case xml.EndElement:
			if token.Name.Space == "" {
				b.WriteString("</" + token.Name.Local)
			} else {
				b.WriteString("</" + token.Name.Space + ":" + token.Name.Local)
			}
			b.WriteByte('>')
		case xml.CharData:
			if x.xt[i].isData {
				xml.EscapeText(b, token)
			} else {
				b.Write(token)
			}
		case xml.ProcInst:
			b.WriteString("<?" + token.Target + " ")
			b.Write(token.Inst)
			b.WriteString("?>")
		case xml.Directive:
			b.WriteString("<!")
			b.Write(token)
			b.WriteString(">")
		case xml.Comment:
			b.WriteString("<!--")
			b.Write(token)
			b.WriteString("-->")
		}
	}

	return b.Bytes()
}
Beispiel #25
0
func encodeDomainInfo(buf *bytes.Buffer, domain string) error {
	buf.Reset()
	buf.WriteString(xmlCommandPrefix)
	buf.WriteString(`<info>`)
	buf.WriteString(`<domain:info xmlns:domain="urn:ietf:params:xml:ns:domain-1.0">`)
	buf.WriteString(`<domain:name>`)
	xml.EscapeText(buf, []byte(domain))
	buf.WriteString(`</domain:name>`)

	buf.WriteString(`</domain:info>`)
	buf.WriteString(`</info>`)

	buf.WriteString(xmlCommandSuffix)
	return nil
}
Beispiel #26
0
func (this *Node) printElement() []byte {
	var b bytes.Buffer

	if len(this.Name.Space) > 0 {
		b.WriteRune('<')
		b.WriteString(this.Name.Space)
		b.WriteRune(':')
		b.WriteString(this.Name.Local)
	} else {
		b.WriteRune('<')
		b.WriteString(this.Name.Local)
	}

	for _, v := range this.Attributes {
		if len(v.Name.Space) > 0 {
			prefix := this.spacePrefix(v.Name.Space)
			b.WriteString(fmt.Sprintf(` %s:%s="%s"`, prefix, v.Name.Local, v.Value))
		} else {
			b.WriteString(fmt.Sprintf(` %s="%s"`, v.Name.Local, v.Value))
		}
	}

	if len(this.Children) == 0 && len(this.Value) == 0 {
		b.WriteString(" />")
		return b.Bytes()
	}

	b.WriteRune('>')

	for _, v := range this.Children {
		b.Write(v.bytes())
	}

	xml.EscapeText(&b, []byte(this.Value))
	if len(this.Name.Space) > 0 {
		b.WriteString("</")
		b.WriteString(this.Name.Space)
		b.WriteRune(':')
		b.WriteString(this.Name.Local)
		b.WriteRune('>')
	} else {
		b.WriteString("</")
		b.WriteString(this.Name.Local)
		b.WriteRune('>')
	}

	return b.Bytes()
}
Beispiel #27
0
// Look for command to execute from request body. The request/response content conform to Twilio SMS hook requirements.
func (sh *WebShell) httpAPIMessage(w http.ResponseWriter, r *http.Request) {
	if cmd := sh.cmdFind(r.FormValue("Body")); cmd == "" {
		// No match, don't give much clue to the client though.
		http.Error(w, "404 page not found", http.StatusNotFound)
	} else {
		output := sh.cmdRun(cmd, sh.WebTimeoutSec, sh.WebTruncateLen, true, true)
		var escapeOutput bytes.Buffer
		if err := xml.EscapeText(&escapeOutput, []byte(output)); err != nil {
			log.Printf("XML escape failed - %v", err)
		}
		w.Header().Set("Content-Type", "text/xml")
		w.Header().Set("Cache-Control", "must-revalidate")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(fmt.Sprintf(`<?xml version="1.0" encoding="UTF-8"?>
<Response><Message>%s</Message></Response>
`, escapeOutput.String())))
	}
}
Beispiel #28
0
func encodeDomainUpdateDS(buf *bytes.Buffer, domain string, add []DSRecord, rem []DSRecord) error {
	buf.Reset()
	buf.WriteString(xmlCommandPrefix)
	buf.WriteString(`<update>`)
	buf.WriteString(`<domain:update xmlns:domain="urn:ietf:params:xml:ns:domain-1.0">`)
	buf.WriteString(`<domain:name>`)
	xml.EscapeText(buf, []byte(domain))
	buf.WriteString(`</domain:name>`)

	buf.WriteString(`</domain:update>`)
	buf.WriteString(`</update>`)
	buf.WriteString(`<extension>`)
	buf.WriteString(`<secDNS:update xmlns:secDNS="urn:ietf:params:xml:ns:secDNS-1.1">`)
	if len(rem) > 0 {
		buf.WriteString(`<secDNS:rem>`)
		for _, dsr := range rem {
			buf.WriteString(`<secDNS:dsData>`)
			buf.WriteString(fmt.Sprintf(`<secDNS:keyTag>%d</secDNS:keyTag>`, dsr.KeyTag))
			buf.WriteString(fmt.Sprintf(`<secDNS:alg>%d</secDNS:alg>`, dsr.Algorithm))
			buf.WriteString(fmt.Sprintf(`<secDNS:digestType>%d</secDNS:digestType>`, dsr.DigestType))
			buf.WriteString(fmt.Sprintf(`<secDNS:digest>%s</secDNS:digest>`, dsr.Digest))
			buf.WriteString(`</secDNS:dsData>`)
		}
		buf.WriteString(`</secDNS:rem>`)
	}
	if len(add) > 0 {
		buf.WriteString(`<secDNS:add>`)
		for _, dsr := range add {
			buf.WriteString(`<secDNS:dsData>`)
			buf.WriteString(fmt.Sprintf(`<secDNS:keyTag>%d</secDNS:keyTag>`, dsr.KeyTag))
			buf.WriteString(fmt.Sprintf(`<secDNS:alg>%d</secDNS:alg>`, dsr.Algorithm))
			buf.WriteString(fmt.Sprintf(`<secDNS:digestType>%d</secDNS:digestType>`, dsr.DigestType))
			buf.WriteString(fmt.Sprintf(`<secDNS:digest>%s</secDNS:digest>`, dsr.Digest))
			buf.WriteString(`</secDNS:dsData>`)
		}
		buf.WriteString(`</secDNS:add>`)
	}
	buf.WriteString(`</secDNS:update>`)
	buf.WriteString(`</extension>`)

	buf.WriteString(xmlCommandSuffix)
	return nil
}
Beispiel #29
0
func escapeXML(s string) string {
	for i := 0; i < len(s); i++ {
		// As an optimization, if s contains only ASCII letters, digits or a
		// few special characters, the escaped value is s itself and we don't
		// need to allocate a buffer and convert between string and []byte.
		switch c := s[i]; {
		case c == ' ' || c == '_' ||
			('+' <= c && c <= '9') || // Digits as well as + , - . and /
			('A' <= c && c <= 'Z') ||
			('a' <= c && c <= 'z'):
			continue
		}
		// Otherwise, go through the full escaping process.
		var buf bytes.Buffer
		xml.EscapeText(&buf, []byte(s))
		return buf.String()
	}
	return s
}
Beispiel #30
0
func (e *Encoder) Attribute(space, local, value string) error {
	var err error
	if e.openStartTag {
		aname := local
		if space != "" {
			prefix, ok := e.namespaces[space]
			if !ok || prefix == "" {
				return errors.New("no prefix for namespace " + space)
			}
			aname = prefix + ":" + local
		}
		if _, err = e.w.WriteString(" " + aname + `="`); err == nil {
			if err = xml.EscapeText(e.w, []byte(value)); err == nil {
				_, err = e.w.WriteString(`"`)
			}
		}
	} else {
		err = errors.New(`attribute after ">"`)
	}
	return err
}