130 lines
2.9 KiB
Go
130 lines
2.9 KiB
Go
// Package envelope is responsible for encoding and decoding SOAP envelopes.
|
|
package envelope
|
|
|
|
import (
|
|
"encoding/xml"
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// Fault implements error, and contains SOAP fault information.
|
|
type Fault struct {
|
|
Code string `xml:"faultcode"`
|
|
String string `xml:"faultstring"`
|
|
Actor string `xml:"faultactor"`
|
|
Detail struct {
|
|
Raw []byte `xml:",innerxml"`
|
|
} `xml:"detail"`
|
|
}
|
|
|
|
func (fe *Fault) Error() string {
|
|
return fmt.Sprintf("SOAP fault code=%s: %s", fe.Code, fe.String)
|
|
}
|
|
|
|
// Various "constant" bytes used in the written envelope.
|
|
var (
|
|
envOpen = []byte(xml.Header + `<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body>`)
|
|
env1 = []byte(`<u:`)
|
|
env2 = []byte(` xmlns:u="`)
|
|
env3 = []byte(`">`)
|
|
env4 = []byte(`</u:`)
|
|
env5 = []byte(`>`)
|
|
envClose = []byte(`</s:Body></s:Envelope>`)
|
|
)
|
|
|
|
// Write marshals a SOAP envelope to the writer. Errors can be from the writer
|
|
// or XML encoding.
|
|
func Write(w io.Writer, action *Action) error {
|
|
// 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.
|
|
// Most of the code in this function is hand-coding the outer XML to work
|
|
// around this.
|
|
|
|
_, err := w.Write(envOpen)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write(env1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = xml.EscapeText(w, []byte(action.XMLName.Local))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write(env2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = xml.EscapeText(w, []byte(action.XMLName.Space))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write(env3)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc := xml.NewEncoder(w)
|
|
err = enc.Encode(action.Args)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = enc.Flush()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write(env4)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
xml.EscapeText(w, []byte(action.XMLName.Local))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write(env5)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write(envClose)
|
|
return err
|
|
}
|
|
|
|
// Read unmarshals a SOAP envelope from the reader. Errors can either be from
|
|
// the reader, XML decoding, or a *Fault.
|
|
func Read(r io.Reader, action *Action) error {
|
|
env := envelope{
|
|
Body: body{
|
|
Action: action,
|
|
},
|
|
}
|
|
|
|
dec := xml.NewDecoder(r)
|
|
err := dec.Decode(&env)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if env.Body.Fault != nil {
|
|
return env.Body.Fault
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type envelope struct {
|
|
XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
|
|
EncodingStyle string `xml:"http://schemas.xmlsoap.org/soap/envelope/ encodingStyle,attr"`
|
|
Body body `xml:"http://schemas.xmlsoap.org/soap/envelope/ Body"`
|
|
}
|
|
|
|
type body struct {
|
|
Fault *Fault `xml:"Fault"`
|
|
Action *Action `xml:",any"`
|
|
}
|
|
|
|
type Action struct {
|
|
XMLName xml.Name
|
|
Args interface{} `xml:",any"`
|
|
}
|