1905 lines
45 KiB
Go
1905 lines
45 KiB
Go
// Package xselinux is the X client API for the SELinux extension.
|
|
package xselinux
|
|
|
|
/*
|
|
This file was generated by xselinux.xml on May 10 2012 8:04:33pm EDT.
|
|
This file is automatically generated. Edit at your peril!
|
|
*/
|
|
|
|
import (
|
|
"github.com/BurntSushi/xgb"
|
|
|
|
"github.com/BurntSushi/xgb/xproto"
|
|
)
|
|
|
|
// Init must be called before using the SELinux extension.
|
|
func Init(c *xgb.Conn) error {
|
|
reply, err := xproto.QueryExtension(c, 7, "SELinux").Reply()
|
|
switch {
|
|
case err != nil:
|
|
return err
|
|
case !reply.Present:
|
|
return xgb.Errorf("No extension named SELinux could be found on on the server.")
|
|
}
|
|
|
|
xgb.ExtLock.Lock()
|
|
c.Extensions["SELinux"] = reply.MajorOpcode
|
|
for evNum, fun := range xgb.NewExtEventFuncs["SELinux"] {
|
|
xgb.NewEventFuncs[int(reply.FirstEvent)+evNum] = fun
|
|
}
|
|
for errNum, fun := range xgb.NewExtErrorFuncs["SELinux"] {
|
|
xgb.NewErrorFuncs[int(reply.FirstError)+errNum] = fun
|
|
}
|
|
xgb.ExtLock.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
xgb.NewExtEventFuncs["SELinux"] = make(map[int]xgb.NewEventFun)
|
|
xgb.NewExtErrorFuncs["SELinux"] = make(map[int]xgb.NewErrorFun)
|
|
}
|
|
|
|
// Skipping definition for base type 'Int8'
|
|
|
|
// Skipping definition for base type 'Card16'
|
|
|
|
// Skipping definition for base type 'Char'
|
|
|
|
// Skipping definition for base type 'Card32'
|
|
|
|
// Skipping definition for base type 'Double'
|
|
|
|
// Skipping definition for base type 'Bool'
|
|
|
|
// Skipping definition for base type 'Float'
|
|
|
|
// Skipping definition for base type 'Card8'
|
|
|
|
// Skipping definition for base type 'Int16'
|
|
|
|
// Skipping definition for base type 'Int32'
|
|
|
|
// Skipping definition for base type 'Void'
|
|
|
|
// Skipping definition for base type 'Byte'
|
|
|
|
// 'ListItem' struct definition
|
|
// Size: ((12 + xgb.Pad((int(ObjectContextLen) * 1))) + xgb.Pad((int(DataContextLen) * 1)))
|
|
type ListItem struct {
|
|
Name xproto.Atom
|
|
ObjectContextLen uint32
|
|
DataContextLen uint32
|
|
ObjectContext string // size: xgb.Pad((int(ObjectContextLen) * 1))
|
|
DataContext string // size: xgb.Pad((int(DataContextLen) * 1))
|
|
}
|
|
|
|
// Struct read ListItem
|
|
func ListItemRead(buf []byte, v *ListItem) int {
|
|
b := 0
|
|
|
|
v.Name = xproto.Atom(xgb.Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.ObjectContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.DataContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
{
|
|
byteString := make([]byte, v.ObjectContextLen)
|
|
copy(byteString[:v.ObjectContextLen], buf[b:])
|
|
v.ObjectContext = string(byteString)
|
|
b += xgb.Pad(int(v.ObjectContextLen))
|
|
}
|
|
|
|
{
|
|
byteString := make([]byte, v.DataContextLen)
|
|
copy(byteString[:v.DataContextLen], buf[b:])
|
|
v.DataContext = string(byteString)
|
|
b += xgb.Pad(int(v.DataContextLen))
|
|
}
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read ListItem
|
|
func ListItemReadList(buf []byte, dest []ListItem) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = ListItem{}
|
|
b += ListItemRead(buf[b:], &dest[i])
|
|
}
|
|
return xgb.Pad(b)
|
|
}
|
|
|
|
// Struct write ListItem
|
|
func (v ListItem) Bytes() []byte {
|
|
buf := make([]byte, ((12 + xgb.Pad((int(v.ObjectContextLen) * 1))) + xgb.Pad((int(v.DataContextLen) * 1))))
|
|
b := 0
|
|
|
|
xgb.Put32(buf[b:], uint32(v.Name))
|
|
b += 4
|
|
|
|
xgb.Put32(buf[b:], v.ObjectContextLen)
|
|
b += 4
|
|
|
|
xgb.Put32(buf[b:], v.DataContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], v.ObjectContext[:v.ObjectContextLen])
|
|
b += xgb.Pad(int(v.ObjectContextLen))
|
|
|
|
copy(buf[b:], v.DataContext[:v.DataContextLen])
|
|
b += xgb.Pad(int(v.DataContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list ListItem
|
|
func ListItemListBytes(buf []byte, list []ListItem) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += xgb.Pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Struct list size ListItem
|
|
func ListItemListSize(list []ListItem) int {
|
|
size := 0
|
|
for _, item := range list {
|
|
size += ((12 + xgb.Pad((int(item.ObjectContextLen) * 1))) + xgb.Pad((int(item.DataContextLen) * 1)))
|
|
}
|
|
return size
|
|
}
|
|
|
|
// Request QueryVersion
|
|
// size: 8
|
|
type QueryVersionCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func QueryVersion(c *xgb.Conn, ClientMajor byte, ClientMinor byte) QueryVersionCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(queryVersionRequest(c, ClientMajor, ClientMinor), cookie)
|
|
return QueryVersionCookie{cookie}
|
|
}
|
|
|
|
func QueryVersionUnchecked(c *xgb.Conn, ClientMajor byte, ClientMinor byte) QueryVersionCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(queryVersionRequest(c, ClientMajor, ClientMinor), cookie)
|
|
return QueryVersionCookie{cookie}
|
|
}
|
|
|
|
// Request reply for QueryVersion
|
|
// size: 12
|
|
type QueryVersionReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ServerMajor uint16
|
|
ServerMinor uint16
|
|
}
|
|
|
|
// Waits and reads reply data from request QueryVersion
|
|
func (cook QueryVersionCookie) Reply() (*QueryVersionReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return queryVersionReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for QueryVersion
|
|
func queryVersionReply(buf []byte) *QueryVersionReply {
|
|
v := new(QueryVersionReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ServerMajor = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.ServerMinor = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for QueryVersion
|
|
func queryVersionRequest(c *xgb.Conn, ClientMajor byte, ClientMinor byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 0 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = ClientMajor
|
|
b += 1
|
|
|
|
buf[b] = ClientMinor
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetDeviceCreateContext
|
|
// size: xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetDeviceCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetDeviceCreateContext
|
|
func SetDeviceCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetDeviceCreateContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setDeviceCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetDeviceCreateContextCookie{cookie}
|
|
}
|
|
|
|
func SetDeviceCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetDeviceCreateContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setDeviceCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetDeviceCreateContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetDeviceCreateContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetDeviceCreateContext
|
|
func setDeviceCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 1 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetDeviceCreateContext
|
|
// size: 4
|
|
type GetDeviceCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetDeviceCreateContext(c *xgb.Conn) GetDeviceCreateContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getDeviceCreateContextRequest(c), cookie)
|
|
return GetDeviceCreateContextCookie{cookie}
|
|
}
|
|
|
|
func GetDeviceCreateContextUnchecked(c *xgb.Conn) GetDeviceCreateContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getDeviceCreateContextRequest(c), cookie)
|
|
return GetDeviceCreateContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetDeviceCreateContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetDeviceCreateContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetDeviceCreateContext
|
|
func (cook GetDeviceCreateContextCookie) Reply() (*GetDeviceCreateContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getDeviceCreateContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetDeviceCreateContext
|
|
func getDeviceCreateContextReply(buf []byte) *GetDeviceCreateContextReply {
|
|
v := new(GetDeviceCreateContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetDeviceCreateContext
|
|
func getDeviceCreateContextRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 2 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetDeviceContext
|
|
// size: xgb.Pad((12 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetDeviceContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetDeviceContext
|
|
func SetDeviceContext(c *xgb.Conn, Device uint32, ContextLen uint32, Context string) SetDeviceContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setDeviceContextRequest(c, Device, ContextLen, Context), cookie)
|
|
return SetDeviceContextCookie{cookie}
|
|
}
|
|
|
|
func SetDeviceContextChecked(c *xgb.Conn, Device uint32, ContextLen uint32, Context string) SetDeviceContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setDeviceContextRequest(c, Device, ContextLen, Context), cookie)
|
|
return SetDeviceContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetDeviceContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetDeviceContext
|
|
func setDeviceContextRequest(c *xgb.Conn, Device uint32, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((12 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 3 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], Device)
|
|
b += 4
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetDeviceContext
|
|
// size: 8
|
|
type GetDeviceContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetDeviceContext(c *xgb.Conn, Device uint32) GetDeviceContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getDeviceContextRequest(c, Device), cookie)
|
|
return GetDeviceContextCookie{cookie}
|
|
}
|
|
|
|
func GetDeviceContextUnchecked(c *xgb.Conn, Device uint32) GetDeviceContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getDeviceContextRequest(c, Device), cookie)
|
|
return GetDeviceContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetDeviceContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetDeviceContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetDeviceContext
|
|
func (cook GetDeviceContextCookie) Reply() (*GetDeviceContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getDeviceContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetDeviceContext
|
|
func getDeviceContextReply(buf []byte) *GetDeviceContextReply {
|
|
v := new(GetDeviceContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetDeviceContext
|
|
func getDeviceContextRequest(c *xgb.Conn, Device uint32) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 4 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], Device)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetWindowCreateContext
|
|
// size: xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetWindowCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetWindowCreateContext
|
|
func SetWindowCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetWindowCreateContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setWindowCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetWindowCreateContextCookie{cookie}
|
|
}
|
|
|
|
func SetWindowCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetWindowCreateContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setWindowCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetWindowCreateContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetWindowCreateContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetWindowCreateContext
|
|
func setWindowCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 5 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetWindowCreateContext
|
|
// size: 4
|
|
type GetWindowCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetWindowCreateContext(c *xgb.Conn) GetWindowCreateContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getWindowCreateContextRequest(c), cookie)
|
|
return GetWindowCreateContextCookie{cookie}
|
|
}
|
|
|
|
func GetWindowCreateContextUnchecked(c *xgb.Conn) GetWindowCreateContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getWindowCreateContextRequest(c), cookie)
|
|
return GetWindowCreateContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetWindowCreateContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetWindowCreateContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetWindowCreateContext
|
|
func (cook GetWindowCreateContextCookie) Reply() (*GetWindowCreateContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getWindowCreateContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetWindowCreateContext
|
|
func getWindowCreateContextReply(buf []byte) *GetWindowCreateContextReply {
|
|
v := new(GetWindowCreateContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetWindowCreateContext
|
|
func getWindowCreateContextRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 6 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetWindowContext
|
|
// size: 8
|
|
type GetWindowContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetWindowContext(c *xgb.Conn, Window xproto.Window) GetWindowContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getWindowContextRequest(c, Window), cookie)
|
|
return GetWindowContextCookie{cookie}
|
|
}
|
|
|
|
func GetWindowContextUnchecked(c *xgb.Conn, Window xproto.Window) GetWindowContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getWindowContextRequest(c, Window), cookie)
|
|
return GetWindowContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetWindowContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetWindowContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetWindowContext
|
|
func (cook GetWindowContextCookie) Reply() (*GetWindowContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getWindowContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetWindowContext
|
|
func getWindowContextReply(buf []byte) *GetWindowContextReply {
|
|
v := new(GetWindowContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetWindowContext
|
|
func getWindowContextRequest(c *xgb.Conn, Window xproto.Window) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 7 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetPropertyCreateContext
|
|
// size: xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetPropertyCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetPropertyCreateContext
|
|
func SetPropertyCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyCreateContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setPropertyCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetPropertyCreateContextCookie{cookie}
|
|
}
|
|
|
|
func SetPropertyCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyCreateContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setPropertyCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetPropertyCreateContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetPropertyCreateContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetPropertyCreateContext
|
|
func setPropertyCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 8 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetPropertyCreateContext
|
|
// size: 4
|
|
type GetPropertyCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetPropertyCreateContext(c *xgb.Conn) GetPropertyCreateContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getPropertyCreateContextRequest(c), cookie)
|
|
return GetPropertyCreateContextCookie{cookie}
|
|
}
|
|
|
|
func GetPropertyCreateContextUnchecked(c *xgb.Conn) GetPropertyCreateContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getPropertyCreateContextRequest(c), cookie)
|
|
return GetPropertyCreateContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetPropertyCreateContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetPropertyCreateContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetPropertyCreateContext
|
|
func (cook GetPropertyCreateContextCookie) Reply() (*GetPropertyCreateContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getPropertyCreateContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetPropertyCreateContext
|
|
func getPropertyCreateContextReply(buf []byte) *GetPropertyCreateContextReply {
|
|
v := new(GetPropertyCreateContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetPropertyCreateContext
|
|
func getPropertyCreateContextRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 9 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetPropertyUseContext
|
|
// size: xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetPropertyUseContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetPropertyUseContext
|
|
func SetPropertyUseContext(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyUseContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setPropertyUseContextRequest(c, ContextLen, Context), cookie)
|
|
return SetPropertyUseContextCookie{cookie}
|
|
}
|
|
|
|
func SetPropertyUseContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyUseContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setPropertyUseContextRequest(c, ContextLen, Context), cookie)
|
|
return SetPropertyUseContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetPropertyUseContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetPropertyUseContext
|
|
func setPropertyUseContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 10 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetPropertyUseContext
|
|
// size: 4
|
|
type GetPropertyUseContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetPropertyUseContext(c *xgb.Conn) GetPropertyUseContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getPropertyUseContextRequest(c), cookie)
|
|
return GetPropertyUseContextCookie{cookie}
|
|
}
|
|
|
|
func GetPropertyUseContextUnchecked(c *xgb.Conn) GetPropertyUseContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getPropertyUseContextRequest(c), cookie)
|
|
return GetPropertyUseContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetPropertyUseContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetPropertyUseContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetPropertyUseContext
|
|
func (cook GetPropertyUseContextCookie) Reply() (*GetPropertyUseContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getPropertyUseContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetPropertyUseContext
|
|
func getPropertyUseContextReply(buf []byte) *GetPropertyUseContextReply {
|
|
v := new(GetPropertyUseContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetPropertyUseContext
|
|
func getPropertyUseContextRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 11 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetPropertyContext
|
|
// size: 12
|
|
type GetPropertyContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetPropertyContext(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getPropertyContextRequest(c, Window, Property), cookie)
|
|
return GetPropertyContextCookie{cookie}
|
|
}
|
|
|
|
func GetPropertyContextUnchecked(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getPropertyContextRequest(c, Window, Property), cookie)
|
|
return GetPropertyContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetPropertyContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetPropertyContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetPropertyContext
|
|
func (cook GetPropertyContextCookie) Reply() (*GetPropertyContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getPropertyContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetPropertyContext
|
|
func getPropertyContextReply(buf []byte) *GetPropertyContextReply {
|
|
v := new(GetPropertyContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetPropertyContext
|
|
func getPropertyContextRequest(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) []byte {
|
|
size := 12
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 12 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
xgb.Put32(buf[b:], uint32(Property))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetPropertyDataContext
|
|
// size: 12
|
|
type GetPropertyDataContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetPropertyDataContext(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyDataContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getPropertyDataContextRequest(c, Window, Property), cookie)
|
|
return GetPropertyDataContextCookie{cookie}
|
|
}
|
|
|
|
func GetPropertyDataContextUnchecked(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyDataContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getPropertyDataContextRequest(c, Window, Property), cookie)
|
|
return GetPropertyDataContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetPropertyDataContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetPropertyDataContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetPropertyDataContext
|
|
func (cook GetPropertyDataContextCookie) Reply() (*GetPropertyDataContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getPropertyDataContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetPropertyDataContext
|
|
func getPropertyDataContextReply(buf []byte) *GetPropertyDataContextReply {
|
|
v := new(GetPropertyDataContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetPropertyDataContext
|
|
func getPropertyDataContextRequest(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) []byte {
|
|
size := 12
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 13 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
xgb.Put32(buf[b:], uint32(Property))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ListProperties
|
|
// size: 8
|
|
type ListPropertiesCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func ListProperties(c *xgb.Conn, Window xproto.Window) ListPropertiesCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(listPropertiesRequest(c, Window), cookie)
|
|
return ListPropertiesCookie{cookie}
|
|
}
|
|
|
|
func ListPropertiesUnchecked(c *xgb.Conn, Window xproto.Window) ListPropertiesCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(listPropertiesRequest(c, Window), cookie)
|
|
return ListPropertiesCookie{cookie}
|
|
}
|
|
|
|
// Request reply for ListProperties
|
|
// size: (32 + ListItemListSize(Properties))
|
|
type ListPropertiesReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
PropertiesLen uint32
|
|
// padding: 20 bytes
|
|
Properties []ListItem // size: ListItemListSize(Properties)
|
|
}
|
|
|
|
// Waits and reads reply data from request ListProperties
|
|
func (cook ListPropertiesCookie) Reply() (*ListPropertiesReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return listPropertiesReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for ListProperties
|
|
func listPropertiesReply(buf []byte) *ListPropertiesReply {
|
|
v := new(ListPropertiesReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.PropertiesLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
v.Properties = make([]ListItem, v.PropertiesLen)
|
|
b += ListItemReadList(buf[b:], v.Properties)
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for ListProperties
|
|
func listPropertiesRequest(c *xgb.Conn, Window xproto.Window) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 14 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetSelectionCreateContext
|
|
// size: xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetSelectionCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetSelectionCreateContext
|
|
func SetSelectionCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionCreateContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setSelectionCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetSelectionCreateContextCookie{cookie}
|
|
}
|
|
|
|
func SetSelectionCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionCreateContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setSelectionCreateContextRequest(c, ContextLen, Context), cookie)
|
|
return SetSelectionCreateContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetSelectionCreateContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetSelectionCreateContext
|
|
func setSelectionCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 15 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetSelectionCreateContext
|
|
// size: 4
|
|
type GetSelectionCreateContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetSelectionCreateContext(c *xgb.Conn) GetSelectionCreateContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getSelectionCreateContextRequest(c), cookie)
|
|
return GetSelectionCreateContextCookie{cookie}
|
|
}
|
|
|
|
func GetSelectionCreateContextUnchecked(c *xgb.Conn) GetSelectionCreateContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getSelectionCreateContextRequest(c), cookie)
|
|
return GetSelectionCreateContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetSelectionCreateContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetSelectionCreateContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetSelectionCreateContext
|
|
func (cook GetSelectionCreateContextCookie) Reply() (*GetSelectionCreateContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getSelectionCreateContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetSelectionCreateContext
|
|
func getSelectionCreateContextReply(buf []byte) *GetSelectionCreateContextReply {
|
|
v := new(GetSelectionCreateContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetSelectionCreateContext
|
|
func getSelectionCreateContextRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 16 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request SetSelectionUseContext
|
|
// size: xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
type SetSelectionUseContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
// Write request to wire for SetSelectionUseContext
|
|
func SetSelectionUseContext(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionUseContextCookie {
|
|
cookie := c.NewCookie(false, false)
|
|
c.NewRequest(setSelectionUseContextRequest(c, ContextLen, Context), cookie)
|
|
return SetSelectionUseContextCookie{cookie}
|
|
}
|
|
|
|
func SetSelectionUseContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionUseContextCookie {
|
|
cookie := c.NewCookie(true, false)
|
|
c.NewRequest(setSelectionUseContextRequest(c, ContextLen, Context), cookie)
|
|
return SetSelectionUseContextCookie{cookie}
|
|
}
|
|
|
|
func (cook SetSelectionUseContextCookie) Check() error {
|
|
return cook.Cookie.Check()
|
|
}
|
|
|
|
// Write request to wire for SetSelectionUseContext
|
|
func setSelectionUseContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
|
|
size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 17 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], ContextLen)
|
|
b += 4
|
|
|
|
copy(buf[b:], Context[:ContextLen])
|
|
b += xgb.Pad(int(ContextLen))
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetSelectionUseContext
|
|
// size: 4
|
|
type GetSelectionUseContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetSelectionUseContext(c *xgb.Conn) GetSelectionUseContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getSelectionUseContextRequest(c), cookie)
|
|
return GetSelectionUseContextCookie{cookie}
|
|
}
|
|
|
|
func GetSelectionUseContextUnchecked(c *xgb.Conn) GetSelectionUseContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getSelectionUseContextRequest(c), cookie)
|
|
return GetSelectionUseContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetSelectionUseContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetSelectionUseContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetSelectionUseContext
|
|
func (cook GetSelectionUseContextCookie) Reply() (*GetSelectionUseContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getSelectionUseContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetSelectionUseContext
|
|
func getSelectionUseContextReply(buf []byte) *GetSelectionUseContextReply {
|
|
v := new(GetSelectionUseContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetSelectionUseContext
|
|
func getSelectionUseContextRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 18 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetSelectionContext
|
|
// size: 8
|
|
type GetSelectionContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetSelectionContext(c *xgb.Conn, Selection xproto.Atom) GetSelectionContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getSelectionContextRequest(c, Selection), cookie)
|
|
return GetSelectionContextCookie{cookie}
|
|
}
|
|
|
|
func GetSelectionContextUnchecked(c *xgb.Conn, Selection xproto.Atom) GetSelectionContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getSelectionContextRequest(c, Selection), cookie)
|
|
return GetSelectionContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetSelectionContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetSelectionContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetSelectionContext
|
|
func (cook GetSelectionContextCookie) Reply() (*GetSelectionContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getSelectionContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetSelectionContext
|
|
func getSelectionContextReply(buf []byte) *GetSelectionContextReply {
|
|
v := new(GetSelectionContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetSelectionContext
|
|
func getSelectionContextRequest(c *xgb.Conn, Selection xproto.Atom) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 19 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], uint32(Selection))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetSelectionDataContext
|
|
// size: 8
|
|
type GetSelectionDataContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetSelectionDataContext(c *xgb.Conn, Selection xproto.Atom) GetSelectionDataContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getSelectionDataContextRequest(c, Selection), cookie)
|
|
return GetSelectionDataContextCookie{cookie}
|
|
}
|
|
|
|
func GetSelectionDataContextUnchecked(c *xgb.Conn, Selection xproto.Atom) GetSelectionDataContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getSelectionDataContextRequest(c, Selection), cookie)
|
|
return GetSelectionDataContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetSelectionDataContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetSelectionDataContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetSelectionDataContext
|
|
func (cook GetSelectionDataContextCookie) Reply() (*GetSelectionDataContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getSelectionDataContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetSelectionDataContext
|
|
func getSelectionDataContextReply(buf []byte) *GetSelectionDataContextReply {
|
|
v := new(GetSelectionDataContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetSelectionDataContext
|
|
func getSelectionDataContextRequest(c *xgb.Conn, Selection xproto.Atom) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 20 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], uint32(Selection))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ListSelections
|
|
// size: 4
|
|
type ListSelectionsCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func ListSelections(c *xgb.Conn) ListSelectionsCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(listSelectionsRequest(c), cookie)
|
|
return ListSelectionsCookie{cookie}
|
|
}
|
|
|
|
func ListSelectionsUnchecked(c *xgb.Conn) ListSelectionsCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(listSelectionsRequest(c), cookie)
|
|
return ListSelectionsCookie{cookie}
|
|
}
|
|
|
|
// Request reply for ListSelections
|
|
// size: (32 + ListItemListSize(Selections))
|
|
type ListSelectionsReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
SelectionsLen uint32
|
|
// padding: 20 bytes
|
|
Selections []ListItem // size: ListItemListSize(Selections)
|
|
}
|
|
|
|
// Waits and reads reply data from request ListSelections
|
|
func (cook ListSelectionsCookie) Reply() (*ListSelectionsReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return listSelectionsReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for ListSelections
|
|
func listSelectionsReply(buf []byte) *ListSelectionsReply {
|
|
v := new(ListSelectionsReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.SelectionsLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
v.Selections = make([]ListItem, v.SelectionsLen)
|
|
b += ListItemReadList(buf[b:], v.Selections)
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for ListSelections
|
|
func listSelectionsRequest(c *xgb.Conn) []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 21 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request GetClientContext
|
|
// size: 8
|
|
type GetClientContextCookie struct {
|
|
*xgb.Cookie
|
|
}
|
|
|
|
func GetClientContext(c *xgb.Conn, Resource uint32) GetClientContextCookie {
|
|
cookie := c.NewCookie(true, true)
|
|
c.NewRequest(getClientContextRequest(c, Resource), cookie)
|
|
return GetClientContextCookie{cookie}
|
|
}
|
|
|
|
func GetClientContextUnchecked(c *xgb.Conn, Resource uint32) GetClientContextCookie {
|
|
cookie := c.NewCookie(false, true)
|
|
c.NewRequest(getClientContextRequest(c, Resource), cookie)
|
|
return GetClientContextCookie{cookie}
|
|
}
|
|
|
|
// Request reply for GetClientContext
|
|
// size: (32 + xgb.Pad((int(ContextLen) * 1)))
|
|
type GetClientContextReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
ContextLen uint32
|
|
// padding: 20 bytes
|
|
Context string // size: xgb.Pad((int(ContextLen) * 1))
|
|
}
|
|
|
|
// Waits and reads reply data from request GetClientContext
|
|
func (cook GetClientContextCookie) Reply() (*GetClientContextReply, error) {
|
|
buf, err := cook.Cookie.Reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return getClientContextReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for GetClientContext
|
|
func getClientContextReply(buf []byte) *GetClientContextReply {
|
|
v := new(GetClientContextReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = xgb.Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = xgb.Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.ContextLen = xgb.Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
{
|
|
byteString := make([]byte, v.ContextLen)
|
|
copy(byteString[:v.ContextLen], buf[b:])
|
|
v.Context = string(byteString)
|
|
b += xgb.Pad(int(v.ContextLen))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// Write request to wire for GetClientContext
|
|
func getClientContextRequest(c *xgb.Conn, Resource uint32) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.Extensions["SELINUX"]
|
|
b += 1
|
|
|
|
buf[b] = 22 // request opcode
|
|
b += 1
|
|
|
|
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
xgb.Put32(buf[b:], Resource)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|