150 lines
4.1 KiB
Go
150 lines
4.1 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
"unicode"
|
|
)
|
|
|
|
// Request represents all XML 'request' nodes.
|
|
// If the request doesn't have a reply, Reply is nil.
|
|
type Request struct {
|
|
srcName string // The Go name of this request.
|
|
xmlName string // The XML name of this request.
|
|
Opcode int
|
|
Combine bool // Not currently used.
|
|
Fields []Field // All fields in the request.
|
|
Reply *Reply // A reply, if one exists for this request.
|
|
}
|
|
|
|
// Initialize creates the proper Go source name for this request.
|
|
// It also initializes the reply if one exists, and all fields in this request.
|
|
func (r *Request) Initialize(p *Protocol) {
|
|
r.srcName = SrcName(p, r.xmlName)
|
|
if p.Name != "xproto" {
|
|
r.srcName = strings.Title(strings.ToLower(p.Name)) + r.srcName
|
|
}
|
|
|
|
if r.Reply != nil {
|
|
r.Reply.Initialize(p)
|
|
}
|
|
for _, field := range r.Fields {
|
|
field.Initialize(p)
|
|
}
|
|
}
|
|
|
|
func (r *Request) SrcName() string {
|
|
return r.srcName
|
|
}
|
|
|
|
func (r *Request) XmlName() string {
|
|
return r.xmlName
|
|
}
|
|
|
|
// ReplyName gets the Go source name of the function that generates a
|
|
// reply type from a slice of bytes.
|
|
// The generated function is not currently exported.
|
|
func (r *Request) ReplyName() string {
|
|
if r.Reply == nil {
|
|
log.Panicf("Cannot call 'ReplyName' on request %s, which has no reply.",
|
|
r.SrcName())
|
|
}
|
|
name := r.SrcName()
|
|
lower := string(unicode.ToLower(rune(name[0]))) + name[1:]
|
|
return fmt.Sprintf("%sReply", lower)
|
|
}
|
|
|
|
// ReplyTypeName gets the Go source name of the type holding all reply data
|
|
// for this request.
|
|
func (r *Request) ReplyTypeName() string {
|
|
if r.Reply == nil {
|
|
log.Panicf("Cannot call 'ReplyName' on request %s, which has no reply.",
|
|
r.SrcName())
|
|
}
|
|
return fmt.Sprintf("%sReply", r.SrcName())
|
|
}
|
|
|
|
// ReqName gets the Go source name of the function that generates a byte
|
|
// slice from a list of parameters.
|
|
// The generated function is not currently exported.
|
|
func (r *Request) ReqName() string {
|
|
name := r.SrcName()
|
|
lower := string(unicode.ToLower(rune(name[0]))) + name[1:]
|
|
return fmt.Sprintf("%sRequest", lower)
|
|
}
|
|
|
|
// CookieName gets the Go source name of the type that holds cookies for
|
|
// this request.
|
|
func (r *Request) CookieName() string {
|
|
return fmt.Sprintf("%sCookie", r.SrcName())
|
|
}
|
|
|
|
// Size for Request needs a context.
|
|
// Namely, if this is an extension, we need to account for *four* bytes
|
|
// of a header (extension opcode, request opcode, and the sequence number).
|
|
// If it's a core protocol request, then we only account for *three*
|
|
// bytes of the header (remove the extension opcode).
|
|
func (r *Request) Size(c *Context) Size {
|
|
size := newFixedSize(0)
|
|
|
|
// If this is a core protocol request, we squeeze in an extra byte of
|
|
// data (from the fields below) between the opcode and the size of the
|
|
// request. In an extension request, this byte is always occupied
|
|
// by the opcode of the request (while the first byte is always occupied
|
|
// by the opcode of the extension).
|
|
if c.protocol.Name == "xproto" {
|
|
size = size.Add(newFixedSize(3))
|
|
} else {
|
|
size = size.Add(newFixedSize(4))
|
|
}
|
|
|
|
for _, field := range r.Fields {
|
|
switch field.(type) {
|
|
case *LocalField: // local fields don't go over the wire
|
|
continue
|
|
case *SingleField:
|
|
// mofos!!!
|
|
if r.SrcName() == "ConfigureWindow" &&
|
|
field.SrcName() == "ValueMask" {
|
|
|
|
continue
|
|
}
|
|
size = size.Add(field.Size())
|
|
default:
|
|
size = size.Add(field.Size())
|
|
}
|
|
}
|
|
return newExpressionSize(&Padding{
|
|
Expr: size.Expression,
|
|
})
|
|
}
|
|
|
|
// Reply encapsulates the fields associated with a 'reply' element.
|
|
type Reply struct {
|
|
Fields []Field
|
|
}
|
|
|
|
// Size gets the number of bytes in this request's reply.
|
|
// A reply always has at least 7 bytes:
|
|
// 1 byte: A reply discriminant (first byte set to 1)
|
|
// 2 bytes: A sequence number
|
|
// 4 bytes: Number of additional bytes in 4-byte units past initial 32 bytes.
|
|
func (r *Reply) Size() Size {
|
|
size := newFixedSize(0)
|
|
|
|
// Account for reply discriminant, sequence number and reply length
|
|
size = size.Add(newFixedSize(7))
|
|
|
|
for _, field := range r.Fields {
|
|
size = size.Add(field.Size())
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (r *Reply) Initialize(p *Protocol) {
|
|
for _, field := range r.Fields {
|
|
field.Initialize(p)
|
|
}
|
|
}
|