# PaCkAgE DaTaStReAm
resourceproto 1 96
# end of header
0707010004a260000081a4000000000000000000000001532668420000012f000000b500010002ffffffffffffffff0000001600000000resourceproto/pkginfo PKG=resourceproto
NAME=resourceproto 1.2.0 i86pc Solaris 10
VERSION=1.2.0
PSTAMP=17th March 2014
VENDOR=X.org
EMAIL=http://cgit.freedesktop.org/xorg/proto/resourceproto/
DESC=X.org X11 ResourceProto protocol headers
ARCH=sparc
CATEGORY=utility
CLASSES=none
BASEDIR=/
ISTATES=S s 1 2 3
RSTATES=S s 1 2 3
0707010004a25f000081a400000000000000000000000153266842000002dc000000b500010002ffffffffffffffff0000001500000000resourceproto/pkgmap : 1 96
1 d none /usr/local/include 0755 root root
1 d none /usr/local/include/X11 0755 root root
1 d none /usr/local/include/X11/extensions 0755 root root
1 f none /usr/local/include/X11/extensions/XResproto.h 0644 root root 5495 36122 1395025958
1 d none /usr/local/lib 0755 root root
1 d none /usr/local/lib/pkgconfig 0755 root root
1 f none /usr/local/lib/pkgconfig/resourceproto.pc 0644 root root 196 18249 1395025958
1 d none /usr/local/share 0755 root root
1 d none /usr/local/share/doc 0755 root root
1 d none /usr/local/share/doc/resourceproto 0755 root root
1 f none /usr/local/share/doc/resourceproto/resproto.txt 0644 root root 18060 23972 1395025958
1 i checkinstall 790 2504 1395025986
1 i pkginfo 303 24632 1395025986
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000b00000000TRAILER!!! 0707010004a260000081a4000000000000000000000001532668420000012f000000b500010002ffffffffffffffff0000000800000000pkginfo PKG=resourceproto
NAME=resourceproto 1.2.0 i86pc Solaris 10
VERSION=1.2.0
PSTAMP=17th March 2014
VENDOR=X.org
EMAIL=http://cgit.freedesktop.org/xorg/proto/resourceproto/
DESC=X.org X11 ResourceProto protocol headers
ARCH=sparc
CATEGORY=utility
CLASSES=none
BASEDIR=/
ISTATES=S s 1 2 3
RSTATES=S s 1 2 3
0707010004a25f000081a400000000000000000000000153266842000002dc000000b500010002ffffffffffffffff0000000700000000pkgmap : 1 96
1 d none /usr/local/include 0755 root root
1 d none /usr/local/include/X11 0755 root root
1 d none /usr/local/include/X11/extensions 0755 root root
1 f none /usr/local/include/X11/extensions/XResproto.h 0644 root root 5495 36122 1395025958
1 d none /usr/local/lib 0755 root root
1 d none /usr/local/lib/pkgconfig 0755 root root
1 f none /usr/local/lib/pkgconfig/resourceproto.pc 0644 root root 196 18249 1395025958
1 d none /usr/local/share 0755 root root
1 d none /usr/local/share/doc 0755 root root
1 d none /usr/local/share/doc/resourceproto 0755 root root
1 f none /usr/local/share/doc/resourceproto/resproto.txt 0644 root root 18060 23972 1395025958
1 i checkinstall 790 2504 1395025986
1 i pkginfo 303 24632 1395025986
0707010004a26f000041ed0000000000000000000000025326684200000000000000b500010002ffffffffffffffff0000000800000000install 0707010004a270000081ed0000000000000000000000015326684200000316000000b500010002ffffffffffffffff0000001500000000install/checkinstall #!/bin/sh
#
expected_bits="64"
expected_release="5.10"
expected_platform="i386"
#
release=`uname -r`
platform=`uname -p`
bits=`isainfo -b`
#
if [ ${platform} != ${expected_platform} ]; then
echo "\n\n\n\tThis package must be installed on a ${expected_platform} architecture\n"
echo "\tAborting installation.\n\n\n"
exit 1
fi
if [ ${release} != ${expected_release} ]; then
echo "\n\n\n\tThis package must be installed on a ${expected_release} machine\n"
echo "\tAborting installation.\n\n\n"
exit 1
fi
#if [ ${bits} != ${expected_bits} ]; then
# echo "\n\n\n\tThis package must be installed on a ${expected_bits} bit machine\n"
# echo "\tYour machine is running a ${bits} bit O.S. currently\n"
# echo "\tAborting installation.\n\n\n"
# exit 1
#fi
exit 0
0707010004a261000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000000500000000root 0707010004a262000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000000900000000root/usr 0707010004a263000041ed0000000000000000000000055326684200000000000000b500010002ffffffffffffffff0000000f00000000root/usr/local 0707010004a268000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000001300000000root/usr/local/lib 0707010004a269000041ed0000000000000000000000025326684200000000000000b500010002ffffffffffffffff0000001d00000000root/usr/local/lib/pkgconfig 0707010004a26a000081a400000000000000000000000153266826000000c4000000b500010002ffffffffffffffff0000002e00000000root/usr/local/lib/pkgconfig/resourceproto.pc prefix=/usr/local
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include
Name: ResourceProto
Description: Resource extension headers
Version: 1.2.0
Cflags: -I${includedir}
0707010004a26b000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000001500000000root/usr/local/share 0707010004a26c000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000001900000000root/usr/local/share/doc 0707010004a26d000041ed0000000000000000000000025326684200000000000000b500010002ffffffffffffffff0000002700000000root/usr/local/share/doc/resourceproto 0707010004a26e000081a4000000000000000000000001532668260000468c000000b500010002ffffffffffffffff0000003400000000root/usr/local/share/doc/resourceproto/resproto.txt DRAFT FOR REVIEW
The X Resource Extension
Version 1.2
Rami Ylimäki
rami.ylimaki@vincit.fi
❧❧❧❧❧❧❧❧❧❧❧
1. Introduction
The protocol description of X Resource Extension version 1.1 has been
either lost or has never been written. This specification documents
version 1.0 based on reverse engineered library and server
code. Version 1.1 has been accidentally released from the version
control and while it doesn't have differences to version 1.0, this
version is labeled 1.2 in order to remove the risk of confusion. In
addition to the 1.0 description, this document introduces a new 1.2
version of the extension.
Version 1.2 is a minor release and therefore the changes are
compatible with the previous version. Main enhancements over version
1.0 are:
- Client identification is now possible. For example, servers
supporting version 1.2 may report PID of local clients.
- Size of any resource can be queried from the server. Servers may not
necessarily support size calculation for every resource. However,
clients have now at least the chance to let the server do resource
size estimation for them.
❧❧❧❧❧❧❧❧❧❧❧
2. Notations used in this document
Notation for data types and requests follows the guidelines set in
sections 2-4 of X Window System Protocol standard.
❧❧❧❧❧❧❧❧❧❧❧
3. Interoperability between version 1.1 and 1.2
Version 1.2 only introduces two new requests. However, these requests
could be seen as generalized versions of existing requests. Even
though we aren't deprecating any old requests, libraries could
implement some old requests using the new ones.
The new XResQueryClientIds request could be used instead of
XResQueryClients.
The new XResQueryResourceBytes request could be used instead of
XResQueryClientPixmapBytes.
Using the old requests is still acceptable because we don't want to
change the semantics of existing requests between version 1.1 and 1.2.
❧❧❧❧❧❧❧❧❧❧❧
4. Data types
4.1 Types in version 1.0
CLIENTXIDRANGE [ resource_base: CARD32
resource_mask: CARD32 ]
This type is used for reply of XResQueryClients in version 1.1. It
represents the range of resource allocated for a client and can be
also used for client identification.
resource_base
First resource ID reserved for a client. Used also to identify the
clients themselves.
resource_mask
Mask that can be used to identify a client from some resource
ID. Just zero the bits indicated by this mask from any resource ID
to identify the client that owns the resource.
CLIENTXID [ client: XID ]
This type identifies a single client by a resource owned by that
client or by the first resource ID allocated for the client
(resource_base of CLIENTXIDRANGE). Whenever a resource ID is used, it
is masked by resource_mask of CLIENTXIDRANGE to find out the client
that owns the resource.
CLIENTRESOURCETYPECOUNT [ resource_type: ATOM
count: CARD32 ]
This type is used for reply of XResQueryClientResources in version
1.1. It represents the number of certain type of resources that are
owned by some client.
resource_type
Atom specifying the type of a resource.
count
Number of resources of the given type owned by a client.
4.2 Types in version 1.2
4.2.1 Types used by XResQueryClientIds
CLIENTIDMASK { ClientXid = 0x1, LocalClientPid = 0x2 }
A bitmask specifying a client identification method. Currently only
the PID of local clients is supported in the form of
LocalClientPid. ClientXid is provided for backward compatibility with
version 1.0 so that the new 1.2 requests (XResQueryClientIds) can be
used in place of the older ones (XResQueryClients).
CLIENTIDSPEC [ client: CLIENTXID or None
mask: SETofCLIENTIDMASK or None ]
A data structure for selecting client IDs.
client
ID of a resource allocated for some client. Only the part
identifying a client is actually used. The resource_base of
CLIENTXIDRANGE can be used if the client doesn't own any
resources. However, any resource ID is accepted because that makes
identifying the owners of existing resources easy. The null
resource None can be used to select all clients.
mask
Collection of identification methods that should be applied on the
client. The special value None can be used to apply all supported
identification methods.
CLIENTIDVALUE [ spec: CLIENTIDSPEC
length: CARD32
value: LISTofCARD32 ]
A data structure specifying a single client ID.
spec
A unique identifier for a specific ID of some client. Wildcards
such as None and bitmask unions aren't allowed. The data structure
must always identify a single client and single ID type. However,
the client doesn't have to be specified as the resource_base of
CLIENTXIDRANGE and can be any resource owned by the client.
length
Specifies the length of an ID in units of CARD32. The length
depends on the ID type. In version 1.2 the lengths are 0 for
ClientXid and 4 for LocalClientPid. The length of ClientXid is 0
because that is already stored in the spec field.
value
Actual ID data. In version 1.2 this is missing for ClientXid and
consists of a single CARD32 for LocalClientPid.
4.2.2 Types used by XResQueryResourceBytes
To better understand how resources are related to each other, it's
useful to introduce the concepts of main resource and cross
reference. By main resource we just mean a normal resource that has a
valid XID. By cross reference we mean a resource that is used by some
other resource.
The same resource may have both of these roles depending on the
context. For example, there could be an ordinary pixmap resource. When
we talk about this resource in isolation the term main resource is
used. We call the exact same resource a cross reference when we are
concentrating on some higher level resource, such as window or
graphics context, that is using the lower level resource. Cross
references may also be internal server resources that don't have a
valid XID.
RESOURCEIDSPEC [ resource: XID or None
type: ATOM or None/AnyPropertyType ]
A data structure for selecting or identifying resources. The
interpretation of fields changes depending on the context. The
differences in interpretation are described below.
resource
An XID of a resource. The null resource None can be used to select
all resources matching some type if the data structure is used in
XResQueryResourceBytes request. The null resource None can be used
to mark private server resources if the data structure is used in
a cross reference of XResQueryResourceBytes reply.
type
An atom identifying the resource type. The null atom
None/AnyPropertyType can be used to select all resource types
matching some resource ID if the data structure is used in
XResQueryResourceBytes request.
RESOURCESIZESPEC [ spec: RESOURCEIDSPEC
bytes: CARD32
ref_count: CARD32
use_count: CARD32 ]
A data structure specifying the size of a single resource.
spec
Uniquely identifies a single resource. Wildcards such as None and
AnyPropertyType aren't allowed for main resources. In cross
references, None is used to mark internal server resources.
bytes
Number of bytes allocated for the resource. The size of a resource
is never divided by a reference count. This is the number of bytes
released in server when there are no more references left to the
resource.
ref_count
Number of total users of the resource. Typically the reference
count is 1 but for pixmaps and other resources used from different
contexts the count may be larger.
use_count
Number of times the resource is used by some other resource. For
main resources this is typically 1, because a resource doesn't
usually use itself recursively. For cross references this is the
number of times the resource is used and is also 1 usually.
RESOURCESIZEVALUE [ size: RESOURCESIZESPEC
num_cross_references: CARD32
cross_references: LISTofRESOURCESIZESPEC ]
A data structure specifying sizes of cross references to other
resources in addition to the main resource size.
size
Size of a main resource.
num_cross_references
Number of cross references to other resources from the main
resource. Currently resources can only have pixmaps as cross
references but this can be extended to other types in the
future. For simple resources this field is therefore 0 and the
cross_references list is missing.
cross_references:
Size specifications for cross references. Note that cross
references may contain resources that don't have a valid XID. For
example, a DRI2 drawable might have a cross reference to a private
pixmap that is used internally in the server only. These private
cross references are contained in this list also. This makes it
possible to emulate XResGetClientPixmapBytes with
XResGetResourceBytes.
❧❧❧❧❧❧❧❧❧❧❧
5. Requests
5.1 Requests in version 1.0
┌───
XResQueryVersion
client_major: CARD8
client_minor: CARD8
▶
server_major: CARD16
server_minor: CARD16
└───
The client sends the highest supported version to the server and the
server sends the highest version it supports, but no higher than the
requested version. Major version changes can introduce
incompatibilities in existing functionality, minor version changes
introduce only backward compatible changes. It is the client's
responsibility to ensure that the server supports a version which is
compatible with its expectations.
client_major
Major X Resource Extension version supported by client.
client_minor
Minor X Resource Extension version supported by client.
server_major
Highest version supported by server that is compatible with
client.
server_minor
Highest version supported by server that is compatible with
client.
┌───
XResQueryClients
▶
num_clients: CARD32
clients: LISTofCLIENTXIDRANGE
└───
The request asks X server to return the list of all currently
connected clients.
num_clients
Number of currently connected clients.
clients
List of XID ranges allocated for the connected clients.
┌───
XResQueryClientResources
client: CLIENTXID
▶
num_types: CARD32
types: LISTofCLIENTRESOURCETYPECOUNT
Errors: Value
└───
This request can be used to ask the number of resources owned by a
client. The server will return the counts of each type of resource.
client
An XID in the resource range of a client. This identifies the
client and not some specific resource.
num_types
Number of different resource types owned by the client.
types
A list of counts for each resource type.
A value error is generated if invalid resource or client XID is given
in the request.
┌───
XResQueryClientPixmapBytes
client: CLIENTXID
▶
bytes: CARD32
bytes_overflow: CARD32
Errors: Value
└───
This request is used to get the pixmap usage of some client. The
returned number is a sum of memory usage of each pixmap that can be
attributed to the given client. Ideally the server goes through all
pixmaps and divides each pixmap size by the pixmap reference count to
get a pixmap reference size. The reference size is then added to the
returned sum if the client happens to be referencing that pixmap. In
practice some pixmap references may be missed, because it would be too
difficult to keep track of all pixmap references. However, the server
will check the most important client resources that are using pixmaps
and tries to estimate the pixmap usage as well as is possible. In
other words, the server need only make a best-effort attempt to
calculate resource source, so actual resource size may differ from
that reported in practice.
client
Identifies a client by an ID in its resource ID range.
bytes:
Number of bytes attributed to pixmap references from the client
resources.
bytes_overflow:
Higher order word for the bytes field in case the sum of pixmap
reference sizes doesn't fit in CARD32.
A value error is generated if invalid resource or client XID is given
in the request.
5.2 Requests in version 1.2
┌───
XResQueryClientIds
num_specs: CARD32
client_specs: LISTofCLIENTIDSPEC
▶
num_ids: CARD32
client_ids: LISTofCLIENTIDVALUE
Errors: Value
└───
XResQueryClientIds can be used to identify a given set of clients with
some identification method. The request sends a list of specifiers
that select clients and identification methods to server. The server
then tries to identify the chosen clients using the identification
methods specified for each client. The server returns IDs for those
clients that were successfully identified. It's not an error condition
if some identification method couldn't be applied to a client. If the
server is unable to identify some clients, they simply aren't included
in the returned list.
The request supports wildcards in the client specifications so that in
the most general case all IDs of all clients can be queried with a
single CLIENTIDSPEC.
The CLIENTIDSPEC of request and CLIENTIDSPEC of CLIENTIDVALUE in reply
usually match each other. For example, if a request selected a client
by a resource ID owned by the client, then the client is identified by
the same resource ID in the reply. This has been done so that it would
be easy to identify an owner of some resource.
However, the CLIENTIDSPEC of returned CLIENTIDVALUE never contains any
wildcards. If the request used a wildcard to specify all clients in a
single CLIENTIDSPEC, then the reply has expanded the wildcard and
returns separate CLIENTIDVALUE records for each client. In this case
wildcarded clients are identified by resource_base of CLIENTXIDRANGE.
The LocalClientPid type of IDs are included in the reply list only if
the client executing the request asked for it and was also a local
client itself. It doesn't make sense for remote clients to ask PIDs of
local clients.
num_specs
Number of client ID specifications.
client_specs
A list specifying identification methods for clients. Supports
multiple identification methods and clients in a single
specification. See CLIENTIDSPEC for details.
num_ids
Number of IDs that were successfully determined. Can be different
from num_specs or even zero if the server didn't support any
identification methods for the given clients.
client_ids
A list specifying ID information for successfully identified
clients. If wildcards were used in a single CLIENTIDSPEC of
client_specs, then multiple CLIENTIDVALUE records may be returned
for that CLIENTIDSPEC. See CLIENTIDVALUE for details.
A Value error is returned if the request specifies an invalid client
XID or invalid identification method type.
┌───
XResQueryResourceBytes
client: CLIENTXID or None
num_specs: CARD32
resource_specs: LISTofRESOURCEIDSPEC
▶
num_sizes: CARD32
sizes: LISTofRESOURCESIZEVALUE
Errors: Atom, Value
└───
XResQueryResourceBytes can be used to ask the sizes of resources from
X server. The request sends a list of specifiers that selects
resources for size calculation. The server tries to calculate the
sizes of chosen resources and returns an estimate for a resource only
if the size could be determined. It's not an error condition if a size
couldn't be calculated. In that case the resources simply aren't
included in the returned list.
The request supports wildcards so that in the most general case sizes
of all resources of all clients can be queried with a single
RESOURCEIDSPEC. However, the reply has all wildcards expanded and
reports a size of a single resource in each RESOURCESIZEVALUE.
client
An ID of a client can be given to limit the query to resources of
that client. Just like in CLIENTIDSPEC, any resource ID can be
given to identify a client and None can be used if the query
shouldn't be limited to a specific client. Note that in some cases
this field is redundant because resource_specs already fully
determines which resources are selected. If the client ID doesn't
match the owner of any resource in resource_specs, no sizes are
returned and no error is generated.
num_specs
Number of resource specifications.
resource_specs
A list of resource specifications. Each specification can either
uniquely identify a single resource or multiple resources if
wildcarding is used. See RESOURCEIDSPEC for details.
num_sizes
Number of resources whose size could be determined. Can be
different from num_specs or even zero if the server didn't support
size calculation for the given resources.
sizes
A list of resource sizes. Each resource size is linked to a unique
resource. Wildcards are never used in the returned size
records. For example, it's not possible to receive a single
RESOURCESIZEVALUE that would specify the size of all pixmaps if
the sizes of pixmap type resources were asked. Instead, a single
RESOURCESIZEVALUE would be returned for each pixmap in that case.
An Atom error is returned if the request specifies an invalid resource
type. A Value error is returned if the request specifies an invalid
XID for a client or a resource.
❧❧❧❧❧❧❧❧❧❧❧
0707010004a264000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000001700000000root/usr/local/include 0707010004a265000041ed0000000000000000000000035326684200000000000000b500010002ffffffffffffffff0000001b00000000root/usr/local/include/X11 0707010004a266000041ed0000000000000000000000025326684200000000000000b500010002ffffffffffffffff0000002600000000root/usr/local/include/X11/extensions 0707010004a267000081a40000000000000000000000015326682600001577000000b500010002ffffffffffffffff0000003200000000root/usr/local/include/X11/extensions/XResproto.h /*
Copyright (c) 2002 XFree86 Inc
*/
#ifndef _XRESPROTO_H
#define _XRESPROTO_H
#define XRES_MAJOR_VERSION 1
#define XRES_MINOR_VERSION 2
#define XRES_NAME "X-Resource"
/* v1.0 */
#define X_XResQueryVersion 0
#define X_XResQueryClients 1
#define X_XResQueryClientResources 2
#define X_XResQueryClientPixmapBytes 3
/* Version 1.1 has been accidentally released from the version */
/* control and while it doesn't have differences to version 1.0, the */
/* next version is labeled 1.2 in order to remove the risk of confusion. */
/* v1.2 */
#define X_XResQueryClientIds 4
#define X_XResQueryResourceBytes 5
typedef struct {
CARD32 resource_base;
CARD32 resource_mask;
} xXResClient;
#define sz_xXResClient 8
typedef struct {
CARD32 resource_type;
CARD32 count;
} xXResType;
#define sz_xXResType 8
/* XResQueryVersion */
typedef struct _XResQueryVersion {
CARD8 reqType;
CARD8 XResReqType;
CARD16 length B16;
CARD8 client_major;
CARD8 client_minor;
CARD16 unused B16;
} xXResQueryVersionReq;
#define sz_xXResQueryVersionReq 8
typedef struct {
CARD8 type;
CARD8 pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD16 server_major B16;
CARD16 server_minor B16;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXResQueryVersionReply;
#define sz_xXResQueryVersionReply 32
/* XResQueryClients */
typedef struct _XResQueryClients {
CARD8 reqType;
CARD8 XResReqType;
CARD16 length B16;
} xXResQueryClientsReq;
#define sz_xXResQueryClientsReq 4
typedef struct {
CARD8 type;
CARD8 pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 num_clients B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXResQueryClientsReply;
#define sz_xXResQueryClientsReply 32
/* XResQueryClientResources */
typedef struct _XResQueryClientResources {
CARD8 reqType;
CARD8 XResReqType;
CARD16 length B16;
CARD32 xid B32;
} xXResQueryClientResourcesReq;
#define sz_xXResQueryClientResourcesReq 8
typedef struct {
CARD8 type;
CARD8 pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 num_types B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXResQueryClientResourcesReply;
#define sz_xXResQueryClientResourcesReply 32
/* XResQueryClientPixmapBytes */
typedef struct _XResQueryClientPixmapBytes {
CARD8 reqType;
CARD8 XResReqType;
CARD16 length B16;
CARD32 xid B32;
} xXResQueryClientPixmapBytesReq;
#define sz_xXResQueryClientPixmapBytesReq 8
typedef struct {
CARD8 type;
CARD8 pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 bytes B32;
CARD32 bytes_overflow B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
} xXResQueryClientPixmapBytesReply;
#define sz_xXResQueryClientPixmapBytesReply 32
/* v1.2 XResQueryClientIds */
#define X_XResClientXIDMask 0x01
#define X_XResLocalClientPIDMask 0x02
typedef struct _XResClientIdSpec {
CARD32 client B32;
CARD32 mask B32;
} xXResClientIdSpec;
#define sz_xXResClientIdSpec 8
typedef struct _XResClientIdValue {
xXResClientIdSpec spec;
CARD32 length B32;
// followed by length CARD32s
} xXResClientIdValue;
#define sz_xResClientIdValue (sz_xXResClientIdSpec + 4)
typedef struct _XResQueryClientIds {
CARD8 reqType;
CARD8 XResReqType;
CARD16 length B16;
CARD32 numSpecs B32;
// followed by numSpecs times XResClientIdSpec
} xXResQueryClientIdsReq;
#define sz_xXResQueryClientIdsReq 8
typedef struct {
CARD8 type;
CARD8 pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 numIds B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
// followed by numIds times XResClientIdValue
} xXResQueryClientIdsReply;
#define sz_xXResQueryClientIdsReply 32
/* v1.2 XResQueryResourceBytes */
typedef struct _XResResourceIdSpec {
CARD32 resource;
CARD32 type;
} xXResResourceIdSpec;
#define sz_xXResResourceIdSpec 8
typedef struct _XResQueryResourceBytes {
CARD8 reqType;
CARD8 XResReqType;
CARD16 length B16;
CARD32 client B32;
CARD32 numSpecs B32;
// followed by numSpecs times XResResourceIdSpec
} xXResQueryResourceBytesReq;
#define sz_xXResQueryResourceBytesReq 12
typedef struct _XResResourceSizeSpec {
xXResResourceIdSpec spec;
CARD32 bytes B32;
CARD32 refCount B32;
CARD32 useCount B32;
} xXResResourceSizeSpec;
#define sz_xXResResourceSizeSpec (sz_xXResResourceIdSpec + 12)
typedef struct _XResResourceSizeValue {
xXResResourceSizeSpec size;
CARD32 numCrossReferences B32;
// followed by numCrossReferences times XResResourceSizeSpec
} xXResResourceSizeValue;
#define sz_xXResResourceSizeValue (sz_xXResResourceSizeSpec + 4)
typedef struct {
CARD8 type;
CARD8 pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 numSizes B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
// followed by numSizes times XResResourceSizeValue
} xXResQueryResourceBytesReply;
#define sz_xXResQueryResourceBytesReply 32
#endif /* _XRESPROTO_H */
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000b00000000TRAILER!!!