Add an XML-RPC codec
Parses and writes calls and responses with Python 2.7 xmlrpclib's and IMVU's PHP server's types, keeping struct member order. Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
dhkatzandClaude Opus 5.5 committed
1 parent
2551888ed6
commit
bee95533c0
2 files changed
+828
No files matched your search
@@ -0,0 +1,525 @@
|
||||
// Package xmlrpc parses and writes XML-RPC calls and responses, keeping
|
||||
// value types and struct member order exactly.
|
||||
package xmlrpc
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"encoding/xml"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// MaxSize is the largest document accepted.
|
||||
const MaxSize = 64 << 20
|
||||
|
||||
// MaxDepth is the deepest nesting of arrays and structs accepted.
|
||||
const MaxDepth = 64
|
||||
|
||||
// Value is one of: int64, bool, string, float64, []byte (base64), DateTime,
|
||||
// []Value (array), Struct, or nil (<nil/>).
|
||||
type Value = any
|
||||
|
||||
// DateTime is dateTime.iso8601 text, kept as is.
|
||||
type DateTime string
|
||||
|
||||
// Member is a struct member.
|
||||
type Member struct {
|
||||
Name string
|
||||
Value Value
|
||||
}
|
||||
|
||||
// Struct is an XML-RPC struct, in document order.
|
||||
type Struct []Member
|
||||
|
||||
// Get returns the value of the first member with the name.
|
||||
func (s Struct) Get(name string) (Value, bool) {
|
||||
for _, m := range s {
|
||||
if m.Name == name {
|
||||
return m.Value, true
|
||||
}
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
// Call is a methodCall.
|
||||
type Call struct {
|
||||
Method string
|
||||
Params []Value
|
||||
}
|
||||
|
||||
// Response is a methodResponse: Params, or Fault if it's set.
|
||||
type Response struct {
|
||||
Params []Value
|
||||
Fault *Fault
|
||||
}
|
||||
|
||||
// Fault is a fault response's code and message.
|
||||
type Fault struct {
|
||||
Code int64
|
||||
String string
|
||||
}
|
||||
|
||||
func (f *Fault) Error() string { return fmt.Sprintf("xmlrpc fault %d: %s", f.Code, f.String) }
|
||||
|
||||
type parser struct{ d *xml.Decoder }
|
||||
|
||||
func newParser(data []byte) (*parser, error) {
|
||||
if len(data) > MaxSize {
|
||||
return nil, errors.New("xmlrpc: document too large")
|
||||
}
|
||||
d := xml.NewDecoder(bytes.NewReader(data))
|
||||
d.Strict = true
|
||||
d.CharsetReader = func(label string, r io.Reader) (io.Reader, error) {
|
||||
switch strings.ToLower(label) {
|
||||
case "utf-8", "utf8", "us-ascii", "ascii":
|
||||
return r, nil
|
||||
}
|
||||
return nil, fmt.Errorf("xmlrpc: unsupported encoding %q", label)
|
||||
}
|
||||
return &parser{d}, nil
|
||||
}
|
||||
|
||||
func (p *parser) token() (xml.Token, error) {
|
||||
t, err := p.d.Token()
|
||||
if err == io.EOF {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
return t, err
|
||||
}
|
||||
|
||||
// next returns the next start or end element, skipping whitespace,
|
||||
// comments and processing instructions.
|
||||
func (p *parser) next() (xml.Token, error) {
|
||||
for {
|
||||
t, err := p.token()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.StartElement, xml.EndElement:
|
||||
return t, nil
|
||||
case xml.CharData:
|
||||
if len(bytes.TrimSpace(t)) != 0 {
|
||||
return nil, fmt.Errorf("xmlrpc: unexpected text %q", string(t))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (p *parser) start(name string) error {
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if s, ok := t.(xml.StartElement); !ok || s.Name.Local != name {
|
||||
return fmt.Errorf("xmlrpc: expected <%s>", name)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *parser) end(name string) error {
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if e, ok := t.(xml.EndElement); !ok || e.Name.Local != name {
|
||||
return fmt.Errorf("xmlrpc: expected </%s>", name)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// text reads character data up to the current element's end.
|
||||
func (p *parser) text() (string, error) {
|
||||
var b strings.Builder
|
||||
for {
|
||||
t, err := p.token()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.CharData:
|
||||
b.Write(t)
|
||||
case xml.EndElement:
|
||||
return b.String(), nil
|
||||
case xml.StartElement:
|
||||
return "", fmt.Errorf("xmlrpc: unexpected <%s>", t.Name.Local)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// eof checks that only whitespace follows the root element.
|
||||
func (p *parser) eof() error {
|
||||
for {
|
||||
t, err := p.d.Token()
|
||||
if err == io.EOF {
|
||||
return nil
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.StartElement, xml.EndElement:
|
||||
return errors.New("xmlrpc: content after document")
|
||||
case xml.CharData:
|
||||
if len(bytes.TrimSpace(t)) != 0 {
|
||||
return errors.New("xmlrpc: content after document")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// value parses a value's content; its <value> start was read.
|
||||
// Bare text is a string, whitespace included.
|
||||
func (p *parser) value(depth int) (Value, error) {
|
||||
var text strings.Builder
|
||||
for {
|
||||
t, err := p.token()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.CharData:
|
||||
text.Write(t)
|
||||
case xml.EndElement:
|
||||
return text.String(), nil
|
||||
case xml.StartElement:
|
||||
if strings.TrimSpace(text.String()) != "" {
|
||||
return nil, errors.New("xmlrpc: text mixed with elements in <value>")
|
||||
}
|
||||
v, err := p.typed(t.Name.Local, depth)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return v, p.end("value")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (p *parser) typed(name string, depth int) (Value, error) {
|
||||
switch name {
|
||||
case "array", "struct":
|
||||
if depth >= MaxDepth {
|
||||
return nil, errors.New("xmlrpc: nested too deeply")
|
||||
}
|
||||
if name == "array" {
|
||||
return p.array(depth + 1)
|
||||
}
|
||||
return p.strct(depth + 1)
|
||||
}
|
||||
s, err := p.text()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch name {
|
||||
case "nil":
|
||||
return nil, nil
|
||||
case "string":
|
||||
return s, nil
|
||||
case "int", "i4", "i8":
|
||||
n, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("xmlrpc: bad <%s> %q", name, s)
|
||||
}
|
||||
return n, nil
|
||||
case "boolean":
|
||||
switch strings.TrimSpace(s) {
|
||||
case "0":
|
||||
return false, nil
|
||||
case "1":
|
||||
return true, nil
|
||||
}
|
||||
return nil, fmt.Errorf("xmlrpc: bad <boolean> %q", s)
|
||||
case "double":
|
||||
f, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("xmlrpc: bad <double> %q", s)
|
||||
}
|
||||
return f, nil
|
||||
case "dateTime.iso8601":
|
||||
return DateTime(s), nil
|
||||
case "base64":
|
||||
b, err := base64.StdEncoding.DecodeString(strings.Join(strings.Fields(s), ""))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("xmlrpc: bad <base64>: %v", err)
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
return nil, fmt.Errorf("xmlrpc: unknown type <%s>", name)
|
||||
}
|
||||
|
||||
func (p *parser) array(depth int) (Value, error) {
|
||||
if err := p.start("data"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
a := []Value{}
|
||||
for {
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.EndElement:
|
||||
return a, p.end("array")
|
||||
case xml.StartElement:
|
||||
if t.Name.Local != "value" {
|
||||
return nil, fmt.Errorf("xmlrpc: unexpected <%s> in <data>", t.Name.Local)
|
||||
}
|
||||
v, err := p.value(depth)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
a = append(a, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (p *parser) strct(depth int) (Value, error) {
|
||||
s := Struct{}
|
||||
for {
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.EndElement:
|
||||
return s, nil
|
||||
case xml.StartElement:
|
||||
if t.Name.Local != "member" {
|
||||
return nil, fmt.Errorf("xmlrpc: unexpected <%s> in <struct>", t.Name.Local)
|
||||
}
|
||||
if err := p.start("name"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
name, err := p.text()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.start("value"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := p.value(depth)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.end("member"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s = append(s, Member{name, v})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// params parses <param> elements up to </params>.
|
||||
func (p *parser) params() ([]Value, error) {
|
||||
ps := []Value{}
|
||||
for {
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case xml.EndElement:
|
||||
return ps, nil
|
||||
case xml.StartElement:
|
||||
if t.Name.Local != "param" {
|
||||
return nil, fmt.Errorf("xmlrpc: unexpected <%s> in <params>", t.Name.Local)
|
||||
}
|
||||
if err := p.start("value"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := p.value(0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.end("param"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ps = append(ps, v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ParseCall parses a methodCall document.
|
||||
func ParseCall(data []byte) (*Call, error) {
|
||||
p, err := newParser(data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.start("methodCall"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.start("methodName"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
method, err := p.text()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c := &Call{Method: strings.TrimSpace(method), Params: []Value{}}
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if s, ok := t.(xml.StartElement); ok && s.Name.Local == "params" {
|
||||
if c.Params, err = p.params(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.end("methodCall"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else if e, ok := t.(xml.EndElement); !ok || e.Name.Local != "methodCall" {
|
||||
return nil, errors.New("xmlrpc: expected <params>")
|
||||
}
|
||||
return c, p.eof()
|
||||
}
|
||||
|
||||
// ParseResponse parses a methodResponse document.
|
||||
func ParseResponse(data []byte) (*Response, error) {
|
||||
p, err := newParser(data)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.start("methodResponse"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
t, err := p.next()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s, _ := t.(xml.StartElement)
|
||||
r := &Response{}
|
||||
switch s.Name.Local {
|
||||
case "params":
|
||||
if r.Params, err = p.params(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
case "fault":
|
||||
if r.Fault, err = p.fault(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
default:
|
||||
return nil, errors.New("xmlrpc: expected <params> or <fault>")
|
||||
}
|
||||
if err := p.end("methodResponse"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return r, p.eof()
|
||||
}
|
||||
|
||||
func (p *parser) fault() (*Fault, error) {
|
||||
if err := p.start("value"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := p.value(0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := p.end("fault"); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
st, _ := v.(Struct)
|
||||
code, _ := st.Get("faultCode")
|
||||
msg, _ := st.Get("faultString")
|
||||
f := &Fault{}
|
||||
var ok1, ok2 bool
|
||||
f.Code, ok1 = code.(int64)
|
||||
f.String, ok2 = msg.(string)
|
||||
if !ok1 || !ok2 {
|
||||
return nil, errors.New("xmlrpc: bad fault")
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
// Marshal writes the call. It panics on a value of an unsupported type.
|
||||
func (c *Call) Marshal() []byte {
|
||||
var b bytes.Buffer
|
||||
b.WriteString("<?xml version='1.0'?>\n<methodCall>\n<methodName>")
|
||||
xml.EscapeText(&b, []byte(c.Method))
|
||||
b.WriteString("</methodName>\n")
|
||||
writeParams(&b, c.Params)
|
||||
b.WriteString("</methodCall>\n")
|
||||
return b.Bytes()
|
||||
}
|
||||
|
||||
// Marshal writes the response. It panics on a value of an unsupported type.
|
||||
func (r *Response) Marshal() []byte {
|
||||
var b bytes.Buffer
|
||||
b.WriteString("<?xml version='1.0'?>\n<methodResponse>\n")
|
||||
if r.Fault != nil {
|
||||
b.WriteString("<fault>\n")
|
||||
writeValue(&b, Struct{{"faultCode", r.Fault.Code}, {"faultString", r.Fault.String}})
|
||||
b.WriteString("</fault>\n")
|
||||
} else {
|
||||
writeParams(&b, r.Params)
|
||||
}
|
||||
b.WriteString("</methodResponse>\n")
|
||||
return b.Bytes()
|
||||
}
|
||||
|
||||
func writeParams(b *bytes.Buffer, ps []Value) {
|
||||
b.WriteString("<params>\n")
|
||||
for _, v := range ps {
|
||||
b.WriteString("<param>\n")
|
||||
writeValue(b, v)
|
||||
b.WriteString("</param>\n")
|
||||
}
|
||||
b.WriteString("</params>\n")
|
||||
}
|
||||
|
||||
// writeText escapes s; xml.EscapeText also escapes quotes and \t\n\r as
|
||||
// character references, so whitespace survives exactly.
|
||||
func writeText(b *bytes.Buffer, s string) { xml.EscapeText(b, []byte(s)) }
|
||||
|
||||
func writeValue(b *bytes.Buffer, v Value) {
|
||||
b.WriteString("<value>")
|
||||
switch v := v.(type) {
|
||||
case nil:
|
||||
b.WriteString("<nil/>")
|
||||
case int64:
|
||||
fmt.Fprintf(b, "<int>%d</int>", v)
|
||||
case int:
|
||||
fmt.Fprintf(b, "<int>%d</int>", v)
|
||||
case bool:
|
||||
if v {
|
||||
b.WriteString("<boolean>1</boolean>")
|
||||
} else {
|
||||
b.WriteString("<boolean>0</boolean>")
|
||||
}
|
||||
case string:
|
||||
b.WriteString("<string>")
|
||||
writeText(b, v)
|
||||
b.WriteString("</string>")
|
||||
case float64:
|
||||
// Shortest round-trip form; Python's float() parses it, NaN and Inf too.
|
||||
fmt.Fprintf(b, "<double>%s</double>", strconv.FormatFloat(v, 'g', -1, 64))
|
||||
case []byte:
|
||||
fmt.Fprintf(b, "<base64>%s</base64>", base64.StdEncoding.EncodeToString(v))
|
||||
case DateTime:
|
||||
b.WriteString("<dateTime.iso8601>")
|
||||
writeText(b, string(v))
|
||||
b.WriteString("</dateTime.iso8601>")
|
||||
case []Value:
|
||||
b.WriteString("<array><data>\n")
|
||||
for _, e := range v {
|
||||
writeValue(b, e)
|
||||
}
|
||||
b.WriteString("</data></array>")
|
||||
case Struct:
|
||||
b.WriteString("<struct>\n")
|
||||
for _, m := range v {
|
||||
b.WriteString("<member>\n<name>")
|
||||
writeText(b, m.Name)
|
||||
b.WriteString("</name>\n")
|
||||
writeValue(b, m.Value)
|
||||
b.WriteString("</member>\n")
|
||||
}
|
||||
b.WriteString("</struct>")
|
||||
default:
|
||||
panic(fmt.Sprintf("xmlrpc: unsupported type %T", v))
|
||||
}
|
||||
b.WriteString("</value>\n")
|
||||
}
|
||||
Reference in new issue
Block a user