rpms/xscope
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
xscope/xscope-1.1-diff_to_git.patch
Yanko Kaneti b394e4b548 Initial import
2009-07-01 05:08:44 +00:00

16684 lines
450 KiB
Diff
Raw Blame History

diff --git a/AUTHORS b/AUTHORS
index 3dd770c..b3bbcec 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1 +1,2 @@
James Peterson, MCC
+Keith Packard
diff --git a/Makefile.am b/Makefile.am
index 89928cf..7bbf2e6 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,5 @@
#
-# Copyright 2008 Sun Microsystems, Inc. All rights reserved.
+# Copyright 2008-2009 Sun Microsystems, Inc. All rights reserved.
# Use subject to license terms.
#
# Permission is hereby granted, free of charge, to any person obtaining a
@@ -30,28 +30,51 @@
bin_PROGRAMS = xscope
-AM_CFLAGS = $(XSCOPE_CFLAGS)
+AM_CFLAGS = $(CWARNFLAGS) $(XSCOPE_CFLAGS)
xscope_LDADD = $(XSCOPE_LIBS)
xscope_SOURCES = \
+ audio.c \
+ bigreqscope.h \
common.c \
decode11.c \
+ decode_bigreq.c \
+ decode_lbx.c \
+ decode_randr.c \
+ decode_render.c \
+ decode_shm.c \
+ decode_wcp.c \
+ decodenas.c \
+ extensions.c \
+ extensions.h \
fd.c \
fd.h \
+ lbxscope.h \
+ nas.h \
print11.c \
+ print_bigreq.c \
+ print_lbx.c \
+ print_randr.c \
+ print_render.c \
+ print_shm.c \
+ print_wcp.c \
+ printnas.c \
proto.h \
prtype.c \
+ randrscope.h \
+ renderscope.h \
+ scope-transport.c \
scope.c \
scope.h \
server.c \
+ shmscope.h \
table11.c \
- x11.h \
- scope-transport.c
+ wcpscope.h \
+ x11.h
appman_PRE = \
xscope.man
-
appmandir = $(APP_MAN_DIR)
appman_DATA = $(appman_PRE:man=@APP_MAN_SUFFIX@)
@@ -63,7 +86,7 @@ MAINTAINERCLEANFILES = ChangeLog
.PHONY: ChangeLog
ChangeLog:
- (GIT_DIR=$(top_srcdir)/.git git-log > .changelog.tmp && mv .changelog.tmp ChangeLog; rm -f .changelog.tmp) || (touch ChangeLog; echo 'git directory not found: installing possibly empty changelog.' >&2)
+ $(CHANGELOG_CMD)
dist-hook: ChangeLog
@@ -90,3 +113,16 @@ SUFFIXES = .$(APP_MAN_SUFFIX) .man
.man.$(APP_MAN_SUFFIX):
sed $(MAN_SUBSTS) < $< > $@
+
+if LINT
+# Check source code with tools like lint & sparse
+
+ALL_LINT_FLAGS=$(LINT_FLAGS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS)
+
+lint: $(BUILT_SOURCES)
+ @for f in $(xscope_SOURCES) ; do \
+ case $$f in *.c) \
+ $(LINT) $(ALL_LINT_FLAGS) $(srcdir)/$$f ;; esac ; \
+ done
+endif LINT
diff --git a/README b/README
index e69de29..39e78b1 100644
--- a/README
+++ b/README
@@ -0,0 +1,91 @@
+
+ XSCOPE -- a program to monitor X11/Client conversations
+
+XSCOPE is a program to monitor the connections between the X11 window
+server and a client program. xscope runs as a separate process. By
+adjusting the host and/or display number that a X11 client attaches
+to, the client is attached to xscope instead of X11. xscope attaches
+to X11 as if it were the client. All bytes from the client are sent
+to xscope which passes them on to X11; All bytes from X11 are sent to
+xscope which sends them on to the client. xscope is transparent to
+the client and X11.
+
+In addition to passing characters back and forth, xscope will print
+information about this traffic on stdout, giving performance and
+debugging information for an X11 client and server.
+
+
+ -------------- -------------- --------------
+ | | | | | |
+ | | ------------> | | ----------> | |
+ | client | | xscope | | server |
+ | | | | | |
+ | | <----------- | | <---------- | |
+ | | | | | |
+ -------------- -------------- --------------
+ |
+ |
+ v
+ trace output to stdout
+
+
+When running with xscope, three processes are involved, potentially all
+on different machines:
+
+X11 -- the X11 window server will be running on machine "A" for Display "B".
+ ("A" is a machine name; "B" is a display number).
+
+xscope -- xscope must be told where the X11 window server is
+ (what machine and what display). The options for xscope are
+ -h<X11-host> and -d<display-number>. In our example, -hA and -dB.
+ Typically the display-number is not given. xscope will not try to
+ connect to X11 until the client connects to xscope.
+
+client -- the client should connect to xscope rather than X11. To avoid
+ changing the code for the client, xscope listens on the same port
+ as X11. If X11 and xscope are on different machines, this works
+ well. However, if X11 and xscope are on the same machine, this
+ creates a port conflict. To resolve this conflict, xscope can
+ be given a different input or output port number, as necessary
+ to avoid the port that X11 is listening to. The client must connect
+ to this offset port number. The input port for xscope is set by
+ -i<port-number>; the output port is set by -o<port-number>. The
+ default input port is 1; the default output port is 0. These ports
+ are offset by the X11 base (6000) and the display number. The client
+ attaches to xscope by changing its display number by the port offset.
+
+For example, with X11 running on "bagel", display 0 (the default), and
+xscope and the client running on "cleo", we would start xscope as
+"xscope -hbagel -i0". The client program could then connect to "X11" on
+"cleo:0", and would be attached to xscope, which would then attach to
+X11 on "bagel:0".
+
+If, however, all three processes were running on "cleo", we would
+start xscope by "xscope -i1". This would cause it to listen on
+port 6001 (which is display 1 for X11). The client would attach to
+X11 on "cleo:1", and xscope would connect through to X11 on "cleo:0".
+
+
+LIMITATIONS:
+
+xscope has been written and used on a Sun3. Additional code may be needed
+for byteswapping on different architectures.
+
+The command line arguments for specifying the real X server should probably
+ be changed to be more consistent with X11R3 applications.
+
+The Imakefile may be incorrect.
+
+The builtin atoms have been wired in directly; they should probably be
+picked up from a header file.
+
+No provision is included for extensions to the base protocol.
+
+There is no code yet to interpret typed commands from the keyboard.
+ It would be possible for a command language at the keyboard to create
+ artificial characters to be sent to X11 or the client as if they were
+ generated by the other, or to dynamically alter requests or replies.
+
+
+
+
diff --git a/audio.c b/audio.c
new file mode 100644
index 0000000..94fd08a
--- /dev/null
+++ b/audio.c
@@ -0,0 +1,500 @@
+/*
+ * $NCDOr: audio.c,v 1.1 1996/07/18 23:25:52 keithp Exp keithp $
+ *
+ * Copyright 1996 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+#include "scope.h"
+#include "nas.h"
+
+#include <sys/uio.h> /* for struct iovec, used by socket.h */
+#include <sys/socket.h> /* for AF_INET, SOCK_STREAM, ... */
+#include <sys/ioctl.h> /* for FIONCLEX, FIONBIO, ... */
+#ifdef SVR4
+#include <sys/filio.h>
+#endif
+#include <fcntl.h>
+#include <netinet/in.h> /* struct sockaddr_in */
+#include <netinet/tcp.h>
+#include <netdb.h> /* struct servent * and struct hostent * */
+#include <errno.h> /* for EINTR, EADDRINUSE, ... */
+
+static void
+ReportFromAudioClient (
+ FD fd,
+ unsigned char *buf,
+ long n)
+{
+ if (NasVerbose) {
+ if (ScopeEnabled) {
+ PrintTime ();
+ fprintf(stdout, "NAS Client%s --> %4ld %s\n",
+ ClientName(fd), n, (n == 1 ? "byte" : "bytes"));
+ }
+ }
+ ProcessBuffer (fd, buf, n);
+}
+
+static void
+ReportFromAudioServer(
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ if (NasVerbose) {
+ if (ScopeEnabled) {
+ PrintTime();
+ fprintf(stdout, "\t\t\t\t\t%4ld %s <-- NAS Server%s\n",
+ n, (n == 1 ? "byte" : "bytes"), ClientName(fd));
+ }
+ }
+ ProcessBuffer(fd, buf, n);
+}
+
+static long StartAudioSetUpMessage (FD fd, const unsigned char *buf, long n);
+static long FinishAudioSetUpMessage (FD fd, const unsigned char *buf, long n);
+static long StartAudioRequest (FD fd, const unsigned char *buf, long n);
+static long FinishAudioRequest (FD fd, const unsigned char *buf, long n);
+static long StartAudioSetUpReply (FD fd, const unsigned char *buf, long n);
+static long FinishAudioSetUpReply (FD fd, const unsigned char *buf, long n);
+static long FinishAudioReply (FD fd, const unsigned char *buf, long n);
+static long AudioServerPacket (FD fd, const unsigned char *buf, long n);
+
+static void
+StartAudioClientConnection(
+ FD fd)
+{
+ enterprocedure("StartAudioClientConnection");
+ /* when a new connection is started, we have no saved bytes */
+ CS[fd].SavedBytes = NULL;
+ CS[fd].SizeofSavedBytes = 0;
+ CS[fd].NumberofSavedBytes = 0;
+ CS[fd].NumberofBytesProcessed = 0;
+
+ /* when a new connection is started, we have no reply Queue */
+ FlushReplyQ(fd);
+
+ /* each new connection gets a request sequence number */
+ CS[fd].SequenceNumber = 0;
+
+ /* we need 12 bytes to start a SetUp message */
+ CS[fd].ByteProcessing = StartAudioSetUpMessage;
+ CS[fd].NumberofBytesNeeded = 12;
+}
+
+static void
+StopAudioClientConnection(
+ FD fd)
+{
+ enterprocedure("StopAudioClientConnection");
+ /* when a new connection is stopped, discard the old buffer */
+
+ if (CS[fd].SizeofSavedBytes > 0)
+ Free((char*)CS[fd].SavedBytes);
+}
+
+static long
+StartAudioSetUpMessage (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short namelength;
+ short datalength;
+
+ enterprocedure("StartSetUpMessage");
+ /*
+ we need the first 12 bytes to be able to determine if, and how many,
+ additional bytes we need for name and data authorization. However, we
+ can't process the first 12 bytes until we get all of them, so
+ return zero bytes used, and increase the number of bytes needed
+ */
+
+ CS[fd].littleEndian = (buf[0] == 'l');
+ CS[ServerHalf(fd)].littleEndian = CS[fd].littleEndian;
+ littleEndian = CS[fd].littleEndian;
+ namelength = IShort(&buf[6]);
+ datalength = IShort(&buf[8]);
+ CS[fd].ByteProcessing = FinishAudioSetUpMessage;
+ CS[fd].NumberofBytesNeeded = n
+ + pad((long)namelength) + pad((long)datalength);
+ debug(8,(stderr, "need %ld bytes to finish startup\n",
+ CS[fd].NumberofBytesNeeded - n));
+ return(0);
+}
+
+static long
+FinishAudioSetUpMessage (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ enterprocedure("FinishSetUpMessage");
+ if (ScopeEnabled)
+ PrintAudioSetUpMessage(buf);
+
+ /* after a set-up message, we expect a string of requests */
+ CS[fd].ByteProcessing = StartAudioRequest;
+ CS[fd].NumberofBytesNeeded = 4;
+ return(n);
+}
+
+
+static long
+StartAudioRequest (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ unsigned short requestlength;
+ enterprocedure("StartRequest");
+
+ /* bytes 0,1 are ignored now; bytes 2,3 tell us the request length */
+ requestlength = IShort(&buf[2]);
+ CS[fd].ByteProcessing = FinishAudioRequest;
+ CS[fd].NumberofBytesNeeded = 4 * requestlength;
+ debug(8,(stderr, "need %ld more bytes to finish request\n",
+ CS[fd].NumberofBytesNeeded - n));
+ return(0);
+}
+
+
+static long
+FinishAudioRequest (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ enterprocedure("FinishRequest");
+ CS[fd].ByteProcessing = StartAudioRequest;
+ CS[fd].NumberofBytesNeeded = 4;
+ if (ScopeEnabled)
+ DecodeAudioRequest(fd, buf, n);
+ return(n);
+}
+
+static void
+StartAudioServerConnection(
+ FD fd)
+{
+ enterprocedure("StartAudioServerConnection");
+ /* when a new connection is started, we have no saved bytes */
+ CS[fd].SavedBytes = NULL;
+ CS[fd].SizeofSavedBytes = 0;
+ CS[fd].NumberofSavedBytes = 0;
+ CS[fd].NumberofBytesProcessed = 0;
+
+ /* when a new connection is started, we have no reply Queue */
+ FlushReplyQ(fd);
+
+ /* we need 8 bytes to start a SetUp reply */
+ CS[fd].ByteProcessing = StartAudioSetUpReply;
+ CS[fd].NumberofBytesNeeded = 8;
+}
+
+static void
+StopAudioServerConnection(
+ FD fd)
+{
+ enterprocedure("StopAudioServerConnection");
+ /* when a new connection is stopped, discard the old buffer */
+
+ if (CS[fd].SizeofSavedBytes > 0)
+ Free((char *)CS[fd].SavedBytes);
+}
+
+static long
+StartAudioSetUpReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short replylength;
+
+ enterprocedure("StartSetUpReply");
+ replylength = IShort(&buf[6]);
+ CS[fd].ByteProcessing = FinishAudioSetUpReply;
+ CS[fd].NumberofBytesNeeded = n + 4 * replylength;
+ debug(8,(stderr, "need %ld bytes to finish startup reply\n",
+ CS[fd].NumberofBytesNeeded - n));
+ return(0);
+}
+
+static long
+FinishAudioSetUpReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ enterprocedure("FinishSetUpReply");
+ if (ScopeEnabled)
+ PrintAudioSetUpReply(buf);
+ CS[fd].ByteProcessing = AudioServerPacket;
+ CS[fd].NumberofBytesNeeded = 32;
+ return(n);
+}
+
+/* ************************************************************ */
+
+static long
+AudioErrorPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ CS[fd].ByteProcessing = AudioServerPacket;
+ CS[fd].NumberofBytesNeeded = 32;
+ DecodeAudioError(fd, buf, n);
+ return(n);
+}
+
+
+static long
+AudioEventPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ CS[fd].ByteProcessing = AudioServerPacket;
+ CS[fd].NumberofBytesNeeded = 32;
+ if (ScopeEnabled)
+ DecodeAudioEvent(fd, buf, n);
+ return(n);
+}
+
+
+static long
+AudioReplyPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ long replylength;
+
+ replylength = ILong(&buf[4]);
+
+ /*
+ Replies may need more bytes, so we compute how many more
+ bytes are needed and ask for them, not using any of the bytes
+ we were given (return(0) to say that no bytes were used).
+ If the replylength is zero (we don't need any more bytes), the
+ number of bytes needed will be the same as what we have, and
+ so the top-level loop will call the next routine immediately
+ with the same buffer of bytes that we were given.
+ */
+
+ CS[fd].ByteProcessing = FinishAudioReply;
+ CS[fd].NumberofBytesNeeded = n + 4 * replylength;
+ debug(8,(stderr, "need %ld bytes to finish reply\n", (4 * replylength)));
+ return(0);
+}
+
+static long
+FinishAudioReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ CS[fd].ByteProcessing = AudioServerPacket;
+ CS[fd].NumberofBytesNeeded = 32;
+ enterprocedure("FinishAudioReply");
+ if (ScopeEnabled)
+ DecodeAudioReply(fd, buf, n);
+ return(n);
+}
+
+static long
+AudioServerPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short PacketType;
+ enterprocedure("ServerPacket");
+
+ PacketType = IByte(&buf[0]);
+ if (PacketType == 0)
+ return(AudioErrorPacket(fd, buf, n));
+ if (PacketType == 1)
+ return(AudioReplyPacket(fd, buf, n));
+ return(AudioEventPacket(fd, buf, n));
+}
+
+static void
+CloseAudioConnection(
+ FD fd)
+{
+ debug(4,(stderr, "close %d and %d\n", fd, FDPair(fd)));
+ StopAudioClientConnection(ServerHalf(fd));
+ StopAudioServerConnection(ClientHalf(fd));
+
+ (void)close(fd);
+ NotUsingFD(fd);
+ (void)close(FDPair(fd));
+ NotUsingFD(FDPair(fd));
+}
+
+/* when we get data from a client, we read it in, copy it to the
+ server for this client, then dump it to the client. Note, we don't
+ have to have a server, if there isn't one. */
+
+static void
+DataFromAudioClient(
+ FD fd)
+{
+ long n;
+ FD ServerFD;
+
+ Verbose = NasVerbose;
+ enterprocedure("DataFromAudioClient");
+ ServerFD = FDPair(fd);
+ if (ServerFD < 0)
+ {
+ ServerFD = ConnectToServer(false);
+ if (ServerFD < 0)
+ {
+ CloseAudioConnection(fd);
+ return;
+ }
+ SetUpPair(fd, ServerFD);
+ }
+
+ n = read(fd, FDinfo[ServerFD].buffer, BUFFER_SIZE);
+ debug(4,(stderr, "read %ld bytes from Client%s\n", n, ClientName(fd)));
+ if (n < 0)
+ {
+ PrintTime();
+ perror("Client --> read error:");
+ CloseAudioConnection(fd);
+ return;
+ }
+ if (n == 0)
+ {
+ PrintTime();
+ if (NasVerbose >= 0)
+ fprintf(stdout, "Client%s --> EOF\n", ClientName(fd));
+ CloseAudioConnection(fd);
+ return;
+ }
+
+ FDinfo[ServerFD].bufcount = n;
+ FDinfo[ServerFD].bufstart = 0;
+
+ FlushFD (ServerFD);
+ /* also report the bytes to standard out */
+ ReportFromAudioClient(fd, FDinfo[ServerFD].buffer, n);
+}
+
+/* ********************************************** */
+/* */
+/* ********************************************** */
+
+/* similar situation for the server, but note that if there is no client,
+ we close the connection down -- don't need a server with no client. */
+
+static void
+DataFromAudioServer(
+ FD fd)
+{
+ long n;
+ FD ClientFD;
+
+ Verbose = NasVerbose;
+ ClientFD = FDPair(fd);
+ if (ClientFD < 0)
+ {
+ CloseAudioConnection(fd);
+ return;
+ }
+
+ enterprocedure("DataFromAudioServer");
+ n = read(fd, (char *)FDinfo[ClientFD].buffer, BUFFER_SIZE);
+ debug(4,(stderr, "read %ld bytes from Server%s\n", n, ClientName(fd)));
+ if (n < 0)
+ {
+ PrintTime();
+ perror("read error <- Server");
+ CloseAudioConnection(fd);
+ return;
+ }
+ if (n == 0)
+ {
+ PrintTime();
+ if (NasVerbose >= 0)
+ fprintf(stdout, "EOF <-- Server%s\n", ClientName(fd));
+ CloseAudioConnection(fd);
+ return;
+ }
+
+ FDinfo[ClientFD].bufcount = n;
+ FDinfo[ClientFD].bufstart = 0;
+ FlushFD (ClientFD);
+
+ /* also report the bytes to standard out */
+ ReportFromAudioServer(fd, FDinfo[ClientFD].buffer, n);
+}
+
+static FD
+ConnectToAudioClient(
+ FD ConnectionSocket)
+{
+ FD ClientFD;
+ ClientFD = AcceptConnection(ConnectionSocket);
+ UsingFD(ClientFD, DataFromAudioClient, FlushFD, NULL);
+ StartAudioClientConnection(ClientFD);
+ return(ClientFD);
+}
+
+static FD ConnectToAudioServer(
+ Boolean report)
+{
+ FD ServerFD;
+ XtransConnInfo trans_conn = NULL; /* transport connection object */
+
+ if (!AudioServerHostName[0])
+ strcpy (AudioServerHostName, ServerHostName);
+ ServerFD = MakeConnection (AudioServerHostName, GetServerport () + 2000, report, &trans_conn);
+ if (ServerFD >= 0)
+ {
+ UsingFD(ServerFD, DataFromAudioServer, FlushFD, trans_conn);
+ StartAudioServerConnection(ServerFD);
+ }
+ return(ServerFD);
+}
+
+void
+NewAudio (
+ FD fd)
+{
+ FD ServerFD = -1;
+ FD ClientFD = -1;
+
+ ClientFD = ConnectToAudioClient(fd);
+ ServerFD = ConnectToAudioServer(true);
+ SetUpPair(ClientFD, ServerFD);
+}
+
+void
+InitializeAudio (void)
+{
+ InitializeAudioDecode ();
+}
diff --git a/bigreqscope.h b/bigreqscope.h
new file mode 100644
index 0000000..0b182c0
--- /dev/null
+++ b/bigreqscope.h
@@ -0,0 +1,22 @@
+#ifndef _BIGREQSCOPE_H_
+#define _BIGREQSCOPE_H_
+
+
+#define BIGREQREQUESTHEADER "BIGREQREQUEST"
+#define BIGREQREPLYHEADER "BIGREQREPLY"
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
+
+extern unsigned char BIGREQRequest;
+
+extern void BigreqEnable (FD fd, const unsigned char *buf);
+extern void BigreqEnableReply (FD fd, const unsigned char *buf);
+
+#endif
+
diff --git a/common.c b/common.c
index 028578b..8d16e6d 100644
--- a/common.c
+++ b/common.c
@@ -54,6 +54,7 @@
\* *********************************************************** */
#include "scope.h"
+#include <fcntl.h>
#ifdef SYSV
#define bzero(s,l) memset(s, 0, l)
@@ -69,22 +70,19 @@
/* ********************************************** */
void
-enterprocedure(s)
- char *s;
+enterprocedure (char *s)
{
debug(2,(stderr, "-> %s\n", s));
}
void
-warn(s)
- char *s;
+warn (char *s)
{
fprintf(stderr, "####### %s\n", s);
}
void
-panic(s)
- char *s;
+panic (char *s)
{
fprintf(stderr, "%s\n", s);
exit(1);
@@ -96,11 +94,12 @@ panic(s)
/* */
/* ********************************************** */
-void *Malloc (long n)
+void *
+Malloc (long n)
{
void *p;
p = malloc(n);
- debug(64,(stderr, "%x = malloc(%d)\n", p, n));
+ debug(64,(stderr, "%lx = malloc(%ld)\n", (unsigned long) p, n));
if (p == NULL)
panic("no more malloc space");
return(p);
@@ -109,7 +108,7 @@ void *Malloc (long n)
void
Free(void *p)
{
- debug(64,(stderr, "%x = free\n", p));
+ debug(64,(stderr, "%lx = free\n", (unsigned long) p));
free(p);
}
@@ -121,6 +120,7 @@ Free(void *p)
/* */
/* ************************************************************ */
+#define __USE_BSD_SIGNAL
#include <signal.h>
static void SignalURG(int sig)
@@ -130,13 +130,15 @@ static void SignalURG(int sig)
static void SignalPIPE(int sig)
{
+ signal (SIGPIPE, SignalPIPE);
debug(1,(stderr, "==> SIGPIPE received\n"));
}
static void SignalINT(int sig)
{
+ signal (SIGINT, SignalINT);
debug(1,(stderr, "==> SIGINT received\n"));
- exit(1);
+ Interrupt = 1;
}
static void SignalQUIT(int sig)
@@ -161,17 +163,25 @@ static void SignalCONT(int sig)
debug(1,(stderr, "==> SIGCONT received\n"));
}
+static void SignalUSR1(int sig)
+{
+ debug(1,(stderr, "==> SIGCONT received\n"));
+ ScopeEnabled = ! ScopeEnabled;
+}
+
void
-SetSignalHandling()
+SetSignalHandling(void)
{
enterprocedure("SetSignalHandling");
- signal(SIGURG, SignalURG);
- signal(SIGPIPE, SignalPIPE);
- signal(SIGINT, SignalINT);
- signal(SIGQUIT, SignalQUIT);
- signal(SIGTERM, SignalTERM);
- signal(SIGTSTP, SignalTSTP);
- signal(SIGCONT, SignalCONT);
+ (void)signal(SIGURG, SignalURG);
+ (void)signal(SIGPIPE, SignalPIPE);
+ (void)signal(SIGINT, SignalINT);
+ (void)signal(SIGQUIT, SignalQUIT);
+ (void)signal(SIGTERM, SignalTERM);
+ (void)signal(SIGTSTP, SignalTSTP);
+ (void)signal(SIGCONT, SignalCONT);
+ if (HandleSIGUSR1)
+ (void)signal(SIGUSR1, SignalUSR1);
}
@@ -199,36 +209,34 @@ static int ListenTransCount;
#include <sys/socket.h> /* for AF_INET, SOCK_STREAM, ... */
#include <sys/ioctl.h> /* for FIONCLEX, FIONBIO, ... */
#include <sys/fcntl.h> /* for FIONCLEX, FIONBIO, ... */
+#ifdef SVR4
+#include <sys/filio.h>
+#endif
+
#include <netinet/in.h> /* struct sockaddr_in */
#include <netdb.h> /* struct servent * and struct hostent * */
-#ifdef DNETCONN
-#include <X11/dni.h>
-#endif
-#ifdef DNETSVR4
-#include <X11/dni8.h>
-#include <dlfcn.h>
-struct hostent *(*dnet_gethostbyname)();
-int (*dnet_gethostname)();
-short initialize_libdni();
-#endif
static int ON = 1 /* used in ioctl */ ;
#define BACKLOG 5
#endif
void
-SetUpConnectionSocket(iport)
- int iport;
+SetUpConnectionSocket(
+ int iport,
+ void (*connectionFunc)(int))
{
#ifdef USE_XTRANS
char port[20];
int partial;
int i;
- extern long ServerBasePort;
#else
FD ConnectionSocket;
struct sockaddr_in sin;
- short port;
+ short port;
+ int one = 1;
+#ifndef SO_DONTLINGER
+ struct linger linger;
+#endif /* SO_DONTLINGER */
#endif
enterprocedure("SetUpConnectionSocket");
@@ -251,7 +259,7 @@ SetUpConnectionSocket(iport)
ListenTransFds[i] = fd;
debug(4,(stderr, "Listening on FD %d\n", fd));
- UsingFD(fd, NewConnection, ListenTransConns[i]);
+ UsingFD(fd, NewConnection, NULL, ListenTransConns[i]);
}
} else {
panic("Could not open any listening connections");
@@ -265,11 +273,17 @@ SetUpConnectionSocket(iport)
perror("socket");
exit(-1);
}
- (void)setsockopt(ConnectionSocket, SOL_SOCKET, SO_REUSEADDR, (char *)NULL, 0);
+ (void)setsockopt(ConnectionSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof (int));
+#ifdef SO_USELOOPBACK
(void)setsockopt(ConnectionSocket, SOL_SOCKET, SO_USELOOPBACK, (char *)NULL, 0);
-#ifdef SO_DONTLINGER
- (void)setsockopt(ConnectionSocket, SOL_SOCKET, SO_DONTLINGER, (char *)NULL, 0);
#endif
+#ifdef SO_DONTLINGER
+ (void)setsockopt(ConnectionSocket, SOL_SOCKET, SO_DONTLINGER, (char *)NULL, 0);
+#else /* SO_DONTLINGER */
+ linger.l_onoff = 0;
+ linger.l_linger = 0;
+ (void)setsockopt(ConnectionSocket, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof linger);
+#endif /* SO_DONTLINGER */
/* define the name and port to be used with the connection socket */
bzero((char *)&sin, sizeof(sin));
@@ -318,129 +332,24 @@ SetUpConnectionSocket(iport)
};
/* a few more parameter settings */
- ioctl(ConnectionSocket, FIOCLEX, 0);
- ioctl(ConnectionSocket, FIONBIO, &ON);
-
- debug(4,(stderr, "Listening on FD %d\n", ConnectionSocket));
- UsingFD(ConnectionSocket, NewConnection);
+#ifdef FD_CLOEXEC
+ (void)fcntl(ConnectionSocket, F_SETFD, FD_CLOEXEC);
+#else
+ (void)ioctl(ConnectionSocket, FIOCLEX, 0);
#endif
-
-}
-
-#ifndef USE_XTRANS
-#ifdef DNETSVR4
-SetUpDECnetConnection(display)
-int display;
-{
- struct sockaddr_dn *sdn,sdnn; /* DECnet socket */
- struct hostent *hp;
- int sock;
- char hostname[6];
-
- if (!initialize_libdni()) {
- fprintf(stderr,"Unable to open libdni.so\n");
- exit(0);
- }
- sdn = &sdnn;
- if (!(dnet_gethostname)(hostname)) {
- fprintf(stderr,"Can't get DECnet local host name\n");
- exit(0);
- }
- if ((hp = (struct hostent *)(dnet_gethostbyname)(hostname)) == NULL) {
- fprintf(stderr,"xhost: can't get name %s\n",hostname);
- exit(0);
- }
- sdn->sdn_family = AF_DECnet;
- sdn->sdn_format = DNADDR_FMT1;
- sdn->sdn_port = 0;
- sprintf ((char *)sdn->sdn_name, "X$X%d", display);
- sdn->sdn_namelen = strlen((char *)sdn->sdn_name);
- sdn->sdn_addr = *(u_short *)hp->h_addr_list[0];
-
- if ((sock = socket (AF_DECnet, SOCK_STREAM, 0)) < 0) {
- perror("socket");
- exit(0);
- }
- (void)setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)NULL, 0);
- (void)setsockopt(sock, SOL_SOCKET, SO_USELOOPBACK, (char *)NULL, 0);
-
- if (bind(sock, (struct sockaddr_dn *)sdn,
- sizeof(struct sockaddr_dn)) < 0) {
- perror("DNI Bind");
- exit(0);
- }
- if (listen(sock, 100) < 0) {
- perror("DNI Listen");
- exit(0);
- }
-
- UsingFD(sock, NewConnection);
-}
+ /* ultrix reads hang on Unix sockets, hpux reads fail */
+#if defined(O_NONBLOCK) && (!defined(ultrix) && !defined(hpux))
+ (void) fcntl (ConnectionSocket, F_SETFL, O_NONBLOCK);
+#else
+#ifdef FIOSNBIO
+ (void) ioctl (ConnectionSocket, FIOSNBIO, &ON);
+#else
+ (void) fcntl (ConnectionSocket, F_SETFL, FNDELAY);
#endif
-
-#ifdef DNETCONN
-SetUpDECnetConnection(display)
-int display;
-{
- struct ses_io_type sesopts;
- char objname[6];
- FD fd;
-
- enterprocedure("SetUpDECnetConnection");
- sprintf (objname, "X$X%d", display);
- if ((fd = open("/dev/dni", O_RDWR)) < 0) {
- fprintf(stderr,"xscope: dni: open failed\n");
- exit(-1);
- }
- if (ioctl(fd, SES_GET_LINK, 0)) {
- fprintf(stderr,"xscope: dni: can't get link\n");
- exit(-1);
- }
- /* set nonblocking here since dni ignores fcntls */
- /* set asyncronous to avoid blocking on SES_GET_AI */
- sesopts.io_flags = SES_IO_NBIO + SES_IO_ASYNCH_MODE;
- sesopts.io_io_signal = SIGIO;
- sesopts.io_int_signal = 0;
-
- if (ioctl(fd, SES_IO_TYPE, &sesopts) < 0) {
- fprintf(stderr,"xscope: dni: ioctl failed\n");
- exit(-1);
- }
-
- /* register as server */
- if (ioctl(fd, SES_NAME_SERVER, objname) < 0) {
- fprintf(stderr,"xscope: dni: ioctl failed\n");
- exit(-1);
- }
- debug(4,(stderr, "Listening on DECnet FD %d\n", fd));
- UsingFD(fd, NewConnection);
-}
#endif
-#ifdef DNETSVR4
-short
-initialize_libdni()
-{
- void *handle;
- char *home;
- char *path;
-
- if (dnet_gethostname && dnet_gethostbyname)
- return(1);
- if (!(handle = dlopen("/etc/openwin/lib/libdni.so",RTLD_NOW))) {
- if ((home = (char *)getenv("DNI_X_ENABLE")) == NULL)
- return(0);
- path = (char *)malloc(strlen(home) + 12);
- sprintf(path, "%s%s",home, "/libdni.so");
- if (!(handle = dlopen(path,RTLD_NOW)))
- return(0);
- free(path);
- }
- if (!(dnet_gethostbyname = (struct hostent *(*)())dlsym(handle,"dni_gethostbyname")))
- return(0);
- if (!(dnet_gethostname = (int (*)())dlsym(handle,"dni_gethostname")))
- return(0);
- return(1);
-}
+ debug(4,(stderr, "Listening on FD %d\n", ConnectionSocket));
+ UsingFD(ConnectionSocket, connectionFunc, NULL, NULL);
#endif
-#endif /* USE_XTRANS */
+}
+
diff --git a/configure.ac b/configure.ac
index fd86a54..9f1a922 100644
--- a/configure.ac
+++ b/configure.ac
@@ -37,7 +37,12 @@ AM_MAINTAINER_MODE
AM_CONFIG_HEADER(config.h)
+# Require xorg-macros: XORG_CWARNFLAGS, XORG_CHANGELOG, XORG_WITH_LINT
+m4_ifndef([XORG_MACROS_VERSION], [AC_FATAL([must install xorg-macros 1.2 or later before running autoconf/autogen])])
+XORG_MACROS_VERSION(1.2)
+
AC_PROG_CC
+XORG_CWARNFLAGS
AC_PROG_INSTALL
dnl Issue an error if xtrans.m4 was not found and XTRANS_CONNECTION_FLAGS macro
@@ -60,5 +65,9 @@ AC_SUBST(XSCOPE_LIBS)
XORG_MANPAGE_SECTIONS
XORG_RELEASE_VERSION
+XORG_CHANGELOG
+
+dnl Allow checking code with lint, sparse, etc.
+XORG_WITH_LINT
AC_OUTPUT([Makefile])
diff --git a/decode11.c b/decode11.c
index c3f5a15..1cd9d30 100644
--- a/decode11.c
+++ b/decode11.c
@@ -55,6 +55,8 @@
#include "scope.h"
#include "x11.h"
+#include "extensions.h"
+#include "lbxscope.h"
#ifdef SYSV
#define bzero(s,l) memset(s, 0, l)
@@ -96,6 +98,7 @@ struct QueueEntry
struct QueueEntry *Next;
long SequenceNumber;
short Request;
+ short RequestMinor;
};
/* free space list of Q entries */
@@ -103,9 +106,11 @@ struct QueueEntry
static struct QueueEntry *FreeQEntries = NULL;
/* ************************************************************ */
-static struct QueueEntry *NewQEntry (SequenceNumber, Request)
- long SequenceNumber;
- short Request;
+static struct QueueEntry *
+NewQEntry (
+ long SequenceNumber,
+ short Request,
+ short RequestMinor)
{
struct QueueEntry *p;
@@ -126,6 +131,7 @@ static struct QueueEntry *NewQEntry (SequenceNumber, Request)
p->Next = NULL;
p->SequenceNumber = SequenceNumber;
p->Request = Request;
+ p->RequestMinor = RequestMinor;
return(p);
}
/* ************************************************************ */
@@ -143,7 +149,7 @@ static struct QueueHeader ReplyQ[StaticMaxFD];
/* ************************************************************ */
void
-InitReplyQ()
+InitReplyQ (void)
{
short i;
for (i = 0; i < StaticMaxFD; i++)
@@ -154,8 +160,8 @@ InitReplyQ()
}
void
-FlushReplyQ(fd)
-FD fd;
+FlushReplyQ (
+ FD fd)
{
struct QueueEntry *p;
struct QueueEntry *NextQEntry;
@@ -175,16 +181,18 @@ FD fd;
}
static void
-DumpReplyQ(fd)
- FD fd;
+DumpReplyQ (
+ FD fd)
{
- fprintf(stderr, "ReplyQ[%d] = { Head 0x%x; Tail 0x%x }\n",
- fd, ReplyQ[fd].Head, ReplyQ[fd].Tail);
+ fprintf(stderr, "ReplyQ[%d] = { Head 0x%lx; Tail 0x%lx }\n",
+ fd, (unsigned long)ReplyQ[fd].Head, (unsigned long)ReplyQ[fd].Tail);
{
struct QueueEntry *p;
for (p = ReplyQ[fd].Head; p != NULL; p = p->Next)
- fprintf(stderr, "0x%x = { Next 0x%x; SequenceNumber %d; Request %d }\n",
- p, p->Next, p->SequenceNumber, p->Request);
+ fprintf(stderr,
+ "0x%lx = { Next 0x%lx; SequenceNumber %ld; Request %d }\n",
+ (unsigned long) p, (unsigned long) p->Next,
+ (unsigned long) p->SequenceNumber, p->Request);
}
}
/* ************************************************************ */
@@ -196,17 +204,19 @@ DumpReplyQ(fd)
with this one */
static void
-SequencedReplyExpected(fd, SequenceNumber, RequestType)
- FD fd;
- long SequenceNumber;
- short RequestType;
+SequencedReplyExpected (
+ FD fd,
+ long SequenceNumber,
+ short RequestType,
+ short RequestMinorType)
{
struct QueueEntry *p;
- debug(8,(stderr, "Reply expected: sequence %d and request type %d for fd %d\n",
- SequenceNumber, RequestType, fd));
+ debug(8,(stderr,
+ "Reply expected: sequence %ld and request type %d,%d for fd %d\n",
+ SequenceNumber, RequestType, RequestMinorType, fd));
/* create a new queue entry */
- p = NewQEntry(SequenceNumber, RequestType);
+ p = NewQEntry(SequenceNumber, RequestType, RequestMinorType);
/* find the server associated with this client */
fd = FDPair(fd);
@@ -219,21 +229,24 @@ SequencedReplyExpected(fd, SequenceNumber, RequestType)
ReplyQ[fd].Head = p;
ReplyQ[fd].Tail = p;
- debug(8,(stderr, "Save sequence %d and request type %d for fd %d\n",
- p->SequenceNumber, p->Request, fd));
+ debug(8,(stderr, "Save sequence %ld and request type %d,%d for fd %d\n",
+ p->SequenceNumber, p->Request, p->RequestMinor, fd));
}
static FD Lastfd;
static long LastSequenceNumber;
static short LastReplyType;
+static short LastReplyMinorType;
/* search for the type of request that is associated with a reply
to the given sequence number for this fd */
-static short CheckReplyTable (fd, SequenceNumber)
- FD fd;
- short SequenceNumber;
+short
+CheckReplyTable (
+ FD fd,
+ short SequenceNumber,
+ short *minorp)
{
struct QueueEntry *p;
struct QueueEntry *trailer;
@@ -250,6 +263,7 @@ static short CheckReplyTable (fd, SequenceNumber)
Lastfd = fd;
LastSequenceNumber = p->SequenceNumber;
LastReplyType = p->Request;
+ LastReplyMinorType = p->RequestMinor;
/* pull the queue entry out of the queue for this fd */
if (trailer == NULL)
@@ -263,8 +277,9 @@ static short CheckReplyTable (fd, SequenceNumber)
p->Next = FreeQEntries;
FreeQEntries = p;
- debug(8,(stderr, "Reply on fd %d for sequence %d is type %d\n",
- fd, SequenceNumber, LastReplyType));
+ debug(8,(stderr, "Reply on fd %d for sequence %d is type %d,%x\n",
+ fd, SequenceNumber, LastReplyType, LastReplyMinorType));
+ *minorp = LastReplyMinorType;
return(LastReplyType);
}
}
@@ -280,12 +295,21 @@ static short CheckReplyTable (fd, SequenceNumber)
/* A reply is expected to the type of request given for the
sequence number associated with this fd */
-static void
-ReplyExpected(fd, Request)
- FD fd;
- short Request;
+void
+ReplyExpected (
+ FD fd,
+ short Request)
+{
+ SequencedReplyExpected(fd, CS[fd].SequenceNumber, Request, 0);
+}
+
+void
+ExtendedReplyExpected (
+ FD fd,
+ short Request,
+ short RequestMinor)
{
- SequencedReplyExpected(fd, CS[fd].SequenceNumber, Request);
+ SequencedReplyExpected(fd, CS[fd].SequenceNumber, Request, RequestMinor);
}
/* ************************************************************ */
@@ -293,432 +317,484 @@ ReplyExpected(fd, Request)
/* This is only used with ListFontsWithInfo */
void
-KeepLastReplyExpected()
+KeepLastReplyExpected (void)
{
- SequencedReplyExpected(Lastfd, LastSequenceNumber, LastReplyType);
+ SequencedReplyExpected(Lastfd, LastSequenceNumber, LastReplyType,
+ LastReplyMinorType);
}
+#define DUMP_REQUEST 0
+#define DUMP_REPLY 1
+#define DUMP_EVENT 2
+#define DUMP_ERROR 3
+
+static const char * const simple_names[] = {
+ "REQUEST",
+ "REPLY ",
+ "EVENT ",
+ "ERROR ",
+};
+
+static void
+SimpleDump (int type, FD fd, short Major, short Minor, long bytes)
+{
+ PrintTime ();
+ fprintf (stdout, "@@%s %3d %3d %3d %7ld\n",
+ simple_names[type],
+ ClientNumber(fd),
+ Major, Minor, bytes);
+}
+
/* ************************************************************ */
/* */
/* */
/* ************************************************************ */
void
-DecodeRequest(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+DecodeRequest (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
short Request = IByte (&buf[0]);
+ short RequestMinor = Request >= 128 ? IByte (&buf[1]) : 0;
+ unsigned long seq;
+
CS[fd].SequenceNumber += 1;
- bcopy ((char *)&(CS[fd].SequenceNumber), (char *)SBf, sizeof(long));
+ seq = CS[fd].SequenceNumber;
+ if (CS[fd].littleEndian) {
+ SBf[0] = seq;
+ SBf[1] = seq >> 8;
+ SBf[2] = seq >> 16;
+ SBf[3] = seq >> 24;
+ } else {
+ SBf[0] = seq >> 24;
+ SBf[1] = seq >> 16;
+ SBf[2] = seq >> 8;
+ SBf[3] = seq;
+ }
SetIndentLevel(PRINTCLIENT);
+ /* Special handling of QueryExtension to save extension names */
+ if (Request == 98)
+ {
+ ProcessQueryExtensionRequest(seq, buf);
+ }
+
+ if (Verbose < 0)
+ {
+ SimpleDump (DUMP_REQUEST, fd, Request, RequestMinor, n);
+ return;
+ }
+
if (Raw || (Verbose > 3))
DumpItem("Request", fd, buf, n);
- if (Request <= 0 || 127 < Request)
- warn("Extended request opcode");
+
+ if (Request < 0 || 127 < Request)
+ {
+ ExtensionRequest(fd, buf, Request);
+ }
else switch (Request)
- {
+ {
case 1:
- CreateWindow(buf);
+ CreateWindow(fd, buf);
break;
case 2:
- ChangeWindowAttributes(buf);
+ ChangeWindowAttributes(fd, buf);
break;
case 3:
- GetWindowAttributes(buf);
+ GetWindowAttributes(fd, buf);
ReplyExpected(fd, Request);
break;
case 4:
- DestroyWindow(buf);
+ DestroyWindow(fd, buf);
break;
case 5:
- DestroySubwindows(buf);
+ DestroySubwindows(fd, buf);
break;
case 6:
- ChangeSaveSet(buf);
+ ChangeSaveSet(fd, buf);
break;
case 7:
- ReparentWindow(buf);
+ ReparentWindow(fd, buf);
break;
case 8:
- MapWindow(buf);
+ MapWindow(fd, buf);
break;
case 9:
- MapSubwindows(buf);
+ MapSubwindows(fd, buf);
break;
case 10:
- UnmapWindow(buf);
+ UnmapWindow(fd, buf);
break;
case 11:
- UnmapSubwindows(buf);
+ UnmapSubwindows(fd, buf);
break;
case 12:
- ConfigureWindow(buf);
+ ConfigureWindow(fd, buf);
break;
case 13:
- CirculateWindow(buf);
+ CirculateWindow(fd, buf);
break;
case 14:
- GetGeometry(buf);
+ GetGeometry(fd, buf);
ReplyExpected(fd, Request);
break;
case 15:
- QueryTree(buf);
+ QueryTree(fd, buf);
ReplyExpected(fd, Request);
break;
case 16:
- InternAtom(buf);
+ InternAtom(fd, buf);
ReplyExpected(fd, Request);
break;
case 17:
- GetAtomName(buf);
+ GetAtomName(fd, buf);
ReplyExpected(fd, Request);
break;
case 18:
- ChangeProperty(buf);
+ ChangeProperty(fd, buf);
break;
case 19:
- DeleteProperty(buf);
+ DeleteProperty(fd, buf);
break;
case 20:
- GetProperty(buf);
+ GetProperty(fd, buf);
ReplyExpected(fd, Request);
break;
case 21:
- ListProperties(buf);
+ ListProperties(fd, buf);
ReplyExpected(fd, Request);
break;
case 22:
- SetSelectionOwner(buf);
+ SetSelectionOwner(fd, buf);
break;
case 23:
- GetSelectionOwner(buf);
+ GetSelectionOwner(fd, buf);
ReplyExpected(fd, Request);
break;
case 24:
- ConvertSelection(buf);
+ ConvertSelection(fd, buf);
break;
case 25:
- SendEvent(buf);
+ SendEvent(fd, buf);
break;
case 26:
- GrabPointer(buf);
+ GrabPointer(fd, buf);
ReplyExpected(fd, Request);
break;
case 27:
- UngrabPointer(buf);
+ UngrabPointer(fd, buf);
break;
case 28:
- GrabButton(buf);
+ GrabButton(fd, buf);
break;
case 29:
- UngrabButton(buf);
+ UngrabButton(fd, buf);
break;
case 30:
- ChangeActivePointerGrab(buf);
+ ChangeActivePointerGrab(fd, buf);
break;
case 31:
- GrabKeyboard(buf);
+ GrabKeyboard(fd, buf);
ReplyExpected(fd, Request);
break;
case 32:
- UngrabKeyboard(buf);
+ UngrabKeyboard(fd, buf);
break;
case 33:
- GrabKey(buf);
+ GrabKey(fd, buf);
break;
case 34:
- UngrabKey(buf);
+ UngrabKey(fd, buf);
break;
case 35:
- AllowEvents(buf);
+ AllowEvents(fd, buf);
break;
case 36:
- GrabServer(buf);
+ GrabServer(fd, buf);
break;
case 37:
- UngrabServer(buf);
+ UngrabServer(fd, buf);
break;
case 38:
- QueryPointer(buf);
+ QueryPointer(fd, buf);
ReplyExpected(fd, Request);
break;
case 39:
- GetMotionEvents(buf);
+ GetMotionEvents(fd, buf);
ReplyExpected(fd, Request);
break;
case 40:
- TranslateCoordinates(buf);
+ TranslateCoordinates(fd, buf);
ReplyExpected(fd, Request);
break;
case 41:
- WarpPointer(buf);
+ WarpPointer(fd, buf);
break;
case 42:
- SetInputFocus(buf);
+ SetInputFocus(fd, buf);
break;
case 43:
- GetInputFocus(buf);
+ GetInputFocus(fd, buf);
ReplyExpected(fd, Request);
break;
case 44:
- QueryKeymap(buf);
+ QueryKeymap(fd, buf);
ReplyExpected(fd, Request);
break;
case 45:
- OpenFont(buf);
+ OpenFont(fd, buf);
break;
case 46:
- CloseFont(buf);
+ CloseFont(fd, buf);
break;
case 47:
- QueryFont(buf);
+ QueryFont(fd, buf);
ReplyExpected(fd, Request);
break;
case 48:
- QueryTextExtents(buf);
+ QueryTextExtents(fd, buf);
ReplyExpected(fd, Request);
break;
case 49:
- ListFonts(buf);
+ ListFonts(fd, buf);
ReplyExpected(fd, Request);
break;
case 50:
- ListFontsWithInfo(buf);
+ ListFontsWithInfo(fd, buf);
ReplyExpected(fd, Request);
break;
case 51:
- SetFontPath(buf);
+ SetFontPath(fd, buf);
break;
case 52:
- GetFontPath(buf);
+ GetFontPath(fd, buf);
ReplyExpected(fd, Request);
break;
case 53:
- CreatePixmap(buf);
+ CreatePixmap(fd, buf);
break;
case 54:
- FreePixmap(buf);
+ FreePixmap(fd, buf);
break;
case 55:
- CreateGC(buf);
+ CreateGC(fd, buf);
break;
case 56:
- ChangeGC(buf);
+ ChangeGC(fd, buf);
break;
case 57:
- CopyGC(buf);
+ CopyGC(fd, buf);
break;
case 58:
- SetDashes(buf);
+ SetDashes(fd, buf);
break;
case 59:
- SetClipRectangles(buf);
+ SetClipRectangles(fd, buf);
break;
case 60:
- FreeGC(buf);
+ FreeGC(fd, buf);
break;
case 61:
- ClearArea(buf);
+ ClearArea(fd, buf);
break;
case 62:
- CopyArea(buf);
+ CopyArea(fd, buf);
break;
case 63:
- CopyPlane(buf);
+ CopyPlane(fd, buf);
break;
case 64:
- PolyPoint(buf);
+ PolyPoint(fd, buf);
break;
case 65:
- PolyLine(buf);
+ PolyLine(fd, buf);
break;
case 66:
- PolySegment(buf);
+ PolySegment(fd, buf);
break;
case 67:
- PolyRectangle(buf);
+ PolyRectangle(fd, buf);
break;
case 68:
- PolyArc(buf);
+ PolyArc(fd, buf);
break;
case 69:
- FillPoly(buf);
+ FillPoly(fd, buf);
break;
case 70:
- PolyFillRectangle(buf);
+ PolyFillRectangle(fd, buf);
break;
case 71:
- PolyFillArc(buf);
+ PolyFillArc(fd, buf);
break;
case 72:
- PutImage(buf);
+ PutImage(fd, buf);
break;
case 73:
- GetImage(buf);
+ GetImage(fd, buf);
ReplyExpected(fd, Request);
break;
case 74:
- PolyText8(buf);
+ PolyText8(fd, buf);
break;
case 75:
- PolyText16(buf);
+ PolyText16(fd, buf);
break;
case 76:
- ImageText8(buf);
+ ImageText8(fd, buf);
break;
case 77:
- ImageText16(buf);
+ ImageText16(fd, buf);
break;
case 78:
- CreateColormap(buf);
+ CreateColormap(fd, buf);
break;
case 79:
- FreeColormap(buf);
+ FreeColormap(fd, buf);
break;
case 80:
- CopyColormapAndFree(buf);
+ CopyColormapAndFree(fd, buf);
break;
case 81:
- InstallColormap(buf);
+ InstallColormap(fd, buf);
break;
case 82:
- UninstallColormap(buf);
+ UninstallColormap(fd, buf);
break;
case 83:
- ListInstalledColormaps(buf);
+ ListInstalledColormaps(fd, buf);
ReplyExpected(fd, Request);
break;
case 84:
- AllocColor(buf);
+ AllocColor(fd, buf);
ReplyExpected(fd, Request);
break;
case 85:
- AllocNamedColor(buf);
+ AllocNamedColor(fd, buf);
ReplyExpected(fd, Request);
break;
case 86:
- AllocColorCells(buf);
+ AllocColorCells(fd, buf);
ReplyExpected(fd, Request);
break;
case 87:
- AllocColorPlanes(buf);
+ AllocColorPlanes(fd, buf);
ReplyExpected(fd, Request);
break;
case 88:
- FreeColors(buf);
+ FreeColors(fd, buf);
break;
case 89:
- StoreColors(buf);
+ StoreColors(fd, buf);
break;
case 90:
- StoreNamedColor(buf);
+ StoreNamedColor(fd, buf);
break;
case 91:
- QueryColors(buf);
+ QueryColors(fd, buf);
ReplyExpected(fd, Request);
break;
case 92:
- LookupColor(buf);
+ LookupColor(fd, buf);
ReplyExpected(fd, Request);
break;
case 93:
- CreateCursor(buf);
+ CreateCursor(fd, buf);
break;
case 94:
- CreateGlyphCursor(buf);
+ CreateGlyphCursor(fd, buf);
break;
case 95:
- FreeCursor(buf);
+ FreeCursor(fd, buf);
break;
case 96:
- RecolorCursor(buf);
+ RecolorCursor(fd, buf);
break;
case 97:
- QueryBestSize(buf);
+ QueryBestSize(fd, buf);
ReplyExpected(fd, Request);
break;
case 98:
- QueryExtension(buf);
+ QueryExtension(fd, buf);
ReplyExpected(fd, Request);
break;
case 99:
- ListExtensions(buf);
+ ListExtensions(fd, buf);
ReplyExpected(fd, Request);
break;
case 100:
- ChangeKeyboardMapping(buf);
+ ChangeKeyboardMapping(fd, buf);
break;
case 101:
- GetKeyboardMapping(buf);
+ GetKeyboardMapping(fd, buf);
ReplyExpected(fd, Request);
break;
case 102:
- ChangeKeyboardControl(buf);
+ ChangeKeyboardControl(fd, buf);
break;
case 103:
- GetKeyboardControl(buf);
+ GetKeyboardControl(fd, buf);
ReplyExpected(fd, Request);
break;
case 104:
- Bell(buf);
+ Bell(fd, buf);
break;
case 105:
- ChangePointerControl(buf);
+ ChangePointerControl(fd, buf);
break;
case 106:
- GetPointerControl(buf);
+ GetPointerControl(fd, buf);
ReplyExpected(fd, Request);
break;
case 107:
- SetScreenSaver(buf);
+ SetScreenSaver(fd, buf);
break;
case 108:
- GetScreenSaver(buf);
+ GetScreenSaver(fd, buf);
ReplyExpected(fd, Request);
break;
case 109:
- ChangeHosts(buf);
+ ChangeHosts(fd, buf);
break;
case 110:
- ListHosts(buf);
+ ListHosts(fd, buf);
ReplyExpected(fd, Request);
break;
case 111:
- SetAccessControl(buf);
+ SetAccessControl(fd, buf);
break;
case 112:
- SetCloseDownMode(buf);
+ SetCloseDownMode(fd, buf);
break;
case 113:
- KillClient(buf);
+ KillClient(fd, buf);
break;
case 114:
- RotateProperties(buf);
+ RotateProperties(fd, buf);
break;
case 115:
- ForceScreenSaver(buf);
+ ForceScreenSaver(fd, buf);
break;
case 116:
- SetPointerMapping(buf);
+ SetPointerMapping(fd, buf);
ReplyExpected(fd, Request);
break;
case 117:
- GetPointerMapping(buf);
+ GetPointerMapping(fd, buf);
ReplyExpected(fd, Request);
break;
case 118:
- SetModifierMapping(buf);
+ SetModifierMapping(fd, buf);
ReplyExpected(fd, Request);
break;
case 119:
- GetModifierMapping(buf);
+ GetModifierMapping(fd, buf);
ReplyExpected(fd, Request);
break;
case 127:
- NoOperation(buf);
+ NoOperation(fd, buf);
break;
default:
warn("Unimplemented request opcode");
@@ -732,26 +808,41 @@ DecodeRequest(fd, buf, n)
/* ************************************************************ */
void
-DecodeReply(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+DecodeReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
short SequenceNumber = IShort (&buf[2]);
- short Request = CheckReplyTable (fd, SequenceNumber);
- if (Request == 0)
- {
- warn("Unexpected reply");
- return;
- }
+ short RequestMinor;
+ short Request = CheckReplyTable (fd, SequenceNumber, &RequestMinor);
+
+ /* Special handling of QueryExtension to save extension names */
+ if (Request == 98)
+ {
+ ProcessQueryExtensionReply(SequenceNumber, buf);
+ }
+
+ if (Verbose < 0)
+ {
+ SimpleDump (DUMP_REPLY, fd, Request, RequestMinor, n);
+ return;
+ }
+
SetIndentLevel(PRINTSERVER);
RBf[0] = Request /* for the PrintField in the Reply procedure */ ;
+ RBf[1] = RequestMinor;
if (Raw || (Verbose > 3))
DumpItem("Reply", fd, buf, n);
- if (Request <= 0 || 127 < Request)
- warn("Extended reply opcode");
+ if (Request < 0 || 127 < Request)
+ {
+ ExtensionReply(fd, buf, Request, RequestMinor);
+ }
else switch (Request)
{
+ case 0:
+ UnknownReply(buf);
+ break;
case 3:
GetWindowAttributesReply(buf);
break;
@@ -884,74 +975,87 @@ DecodeReply(fd, buf, n)
/* ************************************************************ */
void
-DecodeError(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+DecodeError (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- short Error = IByte (&buf[1]);
- SetIndentLevel(PRINTSERVER);
- if (Raw || (Verbose > 3))
- DumpItem("Error", fd, buf, n);
- (void)CheckReplyTable (fd, (short)IShort(&buf[2]));
- if (Error < 1 || Error > 17)
- warn("Extended Error code");
- else switch (Error)
+ short Error = IByte (&buf[1]);
+ short Request = 0;
+ short RequestMinor = 0;
+
+ Request = CheckReplyTable (fd, (short)IShort(&buf[2]), &RequestMinor);
+
+ if (Verbose < 0)
{
- case 1:
- RequestError(buf);
- break;
- case 2:
- ValueError(buf);
- break;
- case 3:
- WindowError(buf);
- break;
- case 4:
- PixmapError(buf);
- break;
- case 5:
- AtomError(buf);
- break;
- case 6:
- CursorError(buf);
- break;
- case 7:
- FontError(buf);
- break;
- case 8:
- MatchError(buf);
- break;
- case 9:
- DrawableError(buf);
- break;
- case 10:
- AccessError(buf);
- break;
- case 11:
- AllocError(buf);
- break;
- case 12:
- ColormapError(buf);
- break;
- case 13:
- GContextError(buf);
- break;
- case 14:
- IDChoiceError(buf);
- break;
- case 15:
- NameError(buf);
- break;
- case 16:
- LengthError(buf);
- break;
- case 17:
- ImplementationError(buf);
- break;
- default:
- warn("Unimplemented error code");
- break;
+ SimpleDump (DUMP_ERROR, fd, Request, RequestMinor, n);
+ return;
+ }
+
+ SetIndentLevel(PRINTSERVER);
+ if (Raw || (Verbose > 3))
+ DumpItem("Error", fd, buf, n);
+
+ if (Error < 1 || Error > 17)
+ {
+ ExtensionError(fd, buf, Error);
+ }
+ else switch (Error)
+ {
+ case 1:
+ RequestError(buf);
+ break;
+ case 2:
+ ValueError(buf);
+ break;
+ case 3:
+ WindowError(buf);
+ break;
+ case 4:
+ PixmapError(buf);
+ break;
+ case 5:
+ AtomError(buf);
+ break;
+ case 6:
+ CursorError(buf);
+ break;
+ case 7:
+ FontError(buf);
+ break;
+ case 8:
+ MatchError(buf);
+ break;
+ case 9:
+ DrawableError(buf);
+ break;
+ case 10:
+ AccessError(buf);
+ break;
+ case 11:
+ AllocError(buf);
+ break;
+ case 12:
+ ColormapError(buf);
+ break;
+ case 13:
+ GContextError(buf);
+ break;
+ case 14:
+ IDChoiceError(buf);
+ break;
+ case 15:
+ NameError(buf);
+ break;
+ case 16:
+ LengthError(buf);
+ break;
+ case 17:
+ ImplementationError(buf);
+ break;
+ default:
+ warn("Unimplemented error code");
+ break;
}
}
@@ -961,120 +1065,137 @@ DecodeError(fd, buf, n)
/* ************************************************************ */
void
-DecodeEvent(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+DecodeEvent (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- short Event = IByte (&buf[0]);
- SetIndentLevel(PRINTSERVER);
- if (Raw || (Verbose > 3))
- DumpItem("Event", fd, buf, n);
- if (Event < 2 || Event > 34)
- warn("Extended Event code");
- else switch (Event)
+ short Event = IByte (&buf[0]);
+ short EventMinor = Event == LBXEvent ? IByte (&buf[1]) : 0;
+
+ if (Verbose < 0)
{
- case 2:
- KeyPressEvent(buf);
- break;
- case 3:
- KeyReleaseEvent(buf);
- break;
- case 4:
- ButtonPressEvent(buf);
- break;
- case 5:
- ButtonReleaseEvent(buf);
- break;
- case 6:
- MotionNotifyEvent(buf);
- break;
- case 7:
- EnterNotifyEvent(buf);
- break;
- case 8:
- LeaveNotifyEvent(buf);
- break;
- case 9:
- FocusInEvent(buf);
- break;
- case 10:
- FocusOutEvent(buf);
- break;
- case 11:
- KeymapNotifyEvent(buf);
- break;
- case 12:
- ExposeEvent(buf);
- break;
- case 13:
- GraphicsExposureEvent(buf);
- break;
- case 14:
- NoExposureEvent(buf);
- break;
- case 15:
- VisibilityNotifyEvent(buf);
- break;
- case 16:
- CreateNotifyEvent(buf);
- break;
- case 17:
- DestroyNotifyEvent(buf);
- break;
- case 18:
- UnmapNotifyEvent(buf);
- break;
- case 19:
- MapNotifyEvent(buf);
- break;
- case 20:
- MapRequestEvent(buf);
- break;
- case 21:
- ReparentNotifyEvent(buf);
- break;
- case 22:
- ConfigureNotifyEvent(buf);
- break;
- case 23:
- ConfigureRequestEvent(buf);
- break;
- case 24:
- GravityNotifyEvent(buf);
- break;
- case 25:
- ResizeRequestEvent(buf);
- break;
- case 26:
- CirculateNotifyEvent(buf);
- break;
- case 27:
- CirculateRequestEvent(buf);
- break;
- case 28:
- PropertyNotifyEvent(buf);
- break;
- case 29:
- SelectionClearEvent(buf);
- break;
- case 30:
- SelectionRequestEvent(buf);
- break;
- case 31:
- SelectionNotifyEvent(buf);
- break;
- case 32:
- ColormapNotifyEvent(buf);
- break;
- case 33:
- ClientMessageEvent(buf);
- break;
- case 34:
- MappingNotifyEvent(buf);
- break;
- default:
- warn("Unimplemented event code");
- break;
+ SimpleDump (DUMP_EVENT, fd, Event, EventMinor, n);
+ return;
+ }
+
+ SetIndentLevel(PRINTSERVER);
+ if (Raw || (Verbose > 3))
+ DumpItem("Event", fd, buf, n);
+ /* high-order bit means SendEvent generated */
+ if (Event & 0x80)
+ {
+ debug(8,(stderr, "SendEvent generated event 0x%x\n", Event));
+ Event = Event & 0x7F;
+ }
+
+ if (Event < 2 || Event > 34)
+ {
+ ExtensionEvent(fd, buf, Event);
+ }
+ else switch (Event)
+ {
+ case 2:
+ KeyPressEvent(buf);
+ break;
+ case 3:
+ KeyReleaseEvent(buf);
+ break;
+ case 4:
+ ButtonPressEvent(buf);
+ break;
+ case 5:
+ ButtonReleaseEvent(buf);
+ break;
+ case 6:
+ MotionNotifyEvent(buf);
+ break;
+ case 7:
+ EnterNotifyEvent(buf);
+ break;
+ case 8:
+ LeaveNotifyEvent(buf);
+ break;
+ case 9:
+ FocusInEvent(buf);
+ break;
+ case 10:
+ FocusOutEvent(buf);
+ break;
+ case 11:
+ KeymapNotifyEvent(buf);
+ break;
+ case 12:
+ ExposeEvent(buf);
+ break;
+ case 13:
+ GraphicsExposureEvent(buf);
+ break;
+ case 14:
+ NoExposureEvent(buf);
+ break;
+ case 15:
+ VisibilityNotifyEvent(buf);
+ break;
+ case 16:
+ CreateNotifyEvent(buf);
+ break;
+ case 17:
+ DestroyNotifyEvent(buf);
+ break;
+ case 18:
+ UnmapNotifyEvent(buf);
+ break;
+ case 19:
+ MapNotifyEvent(buf);
+ break;
+ case 20:
+ MapRequestEvent(buf);
+ break;
+ case 21:
+ ReparentNotifyEvent(buf);
+ break;
+ case 22:
+ ConfigureNotifyEvent(buf);
+ break;
+ case 23:
+ ConfigureRequestEvent(buf);
+ break;
+ case 24:
+ GravityNotifyEvent(buf);
+ break;
+ case 25:
+ ResizeRequestEvent(buf);
+ break;
+ case 26:
+ CirculateNotifyEvent(buf);
+ break;
+ case 27:
+ CirculateRequestEvent(buf);
+ break;
+ case 28:
+ PropertyNotifyEvent(buf);
+ break;
+ case 29:
+ SelectionClearEvent(buf);
+ break;
+ case 30:
+ SelectionRequestEvent(buf);
+ break;
+ case 31:
+ SelectionNotifyEvent(buf);
+ break;
+ case 32:
+ ColormapNotifyEvent(buf);
+ break;
+ case 33:
+ ClientMessageEvent(buf);
+ break;
+ case 34:
+ MappingNotifyEvent(buf);
+ break;
+ default:
+ warn("Unimplemented event code");
+ break;
}
}
diff --git a/decode_bigreq.c b/decode_bigreq.c
new file mode 100644
index 0000000..be0d597
--- /dev/null
+++ b/decode_bigreq.c
@@ -0,0 +1,81 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "scope.h"
+#include "x11.h"
+#include "bigreqscope.h"
+#include "extensions.h"
+
+unsigned char BIGREQRequest;
+
+void
+bigreq_decode_req (
+ FD fd,
+ const unsigned char *buf)
+{
+ short Major = IByte (&buf[0]);
+ short Minor = IByte (&buf[1]);
+
+ switch (Minor) {
+ case 0:
+ CS[fd].bigreqEnabled = 1;
+ BigreqEnable (fd, buf);
+ ExtendedReplyExpected (fd, Major, Minor); break;
+ default:
+ break;
+ }
+}
+
+void
+bigreq_decode_reply (
+ FD fd,
+ const unsigned char *buf,
+ short RequestMinor)
+{
+ switch (RequestMinor) {
+ case 0: BigreqEnableReply (fd, buf); break;
+ }
+}
+
+void
+InitializeBIGREQ(
+ const unsigned char *buf)
+{
+ TYPE p;
+
+ BIGREQRequest = (unsigned char)(buf[9]);
+
+ DefineEValue (&TD[REQUEST], (unsigned long) BIGREQRequest, "BigreqRequest");
+ DefineEValue (&TD[REPLY], (unsigned long) BIGREQRequest, "BigreqReply");
+
+ p = DefineType(BIGREQREQUEST, ENUMERATED, "BIGREQREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 0L, "BigreqEnable");
+
+ p = DefineType(BIGREQREPLY, ENUMERATED, "BIGREQREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "BigreqEnable");
+}
diff --git a/decode_lbx.c b/decode_lbx.c
new file mode 100644
index 0000000..dd74657
--- /dev/null
+++ b/decode_lbx.c
@@ -0,0 +1,152 @@
+/*
+ * $NCDId$
+ *
+ * Copyright 1992 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#define _XLBX_SERVER_
+#include "scope.h"
+#include "x11.h"
+#include "lbxscope.h"
+#include "extensions.h"
+
+unsigned char LBXRequest, LBXEvent, LBXError;
+
+void
+lbx_decode_req (
+ FD fd,
+ const unsigned char *buf)
+{
+ short Major = IByte (&buf[0]);
+ short Minor = IByte (&buf[1]);
+
+ switch (Minor) {
+ case 0:
+ LbxQueryVersion (fd, buf);
+ ExtendedReplyExpected (fd, Major, Minor);
+ break;
+ case 1:
+ LbxStartProxy (fd, buf);
+ break;
+ case 2:
+ LbxStopProxy (fd, buf);
+ break;
+ case 3:
+ LbxSwitch (fd, buf);
+ break;
+ case 4:
+ LbxNewClient(fd, buf);
+ break;
+ case 5:
+ LbxCloseClient (fd, buf);
+ break;
+ case 6:
+ LbxModifySequence (fd, buf);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+lbx_decode_reply (
+ FD fd,
+ const unsigned char *buf,
+ short RequestMinor)
+{
+ switch (RequestMinor) {
+ case 0:
+ LbxQueryVersionReply (fd, buf);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+lbx_decode_error (
+ FD fd,
+ const unsigned char *buf)
+{
+ short error = IByte(&buf[1]) - LBXError;
+
+ switch (error) {
+ case 0:
+ break;
+ default:
+ break;
+ }
+}
+
+void
+lbx_decode_event (
+ FD fd,
+ const unsigned char *buf)
+{
+ short event = IByte(&buf[0]) - LBXEvent;
+
+ switch (event) {
+ case 0:
+ LbxSwitchEvent (fd, buf);
+ break;
+ case 1:
+ LbxCloseEvent (fd, buf);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+InitializeLBX (
+ const unsigned char *buf)
+{
+ TYPE p;
+
+ LBXRequest = (unsigned char)(buf[9]);
+ LBXEvent = (unsigned char)(buf[10]);
+ LBXError = (unsigned char)(buf[11]);
+
+ DefineEValue (&TD[REQUEST], (unsigned long) LBXRequest, "LbxRequest");
+ DefineEValue (&TD[REPLY], (unsigned long) LBXRequest, "LbxReply");
+ DefineEValue (&TD[EVENT], (unsigned long) LBXEvent, "LbxEvent");
+ DefineEValue (&TD[ERROR], (unsigned long) LBXError, "LbxError");
+
+ p = DefineType(LBXREQUEST, ENUMERATED, "LBXREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 0L, "QueryVersion");
+ DefineEValue(p, 1L, "StartProxy");
+ DefineEValue(p, 2L, "StopProxy");
+ DefineEValue(p, 3L, "Switch");
+ DefineEValue(p, 4L, "NewClient");
+ DefineEValue(p, 5L, "CloseClient");
+ DefineEValue(p, 6L, "ModifySequence");
+
+ p = DefineType(LBXREPLY, ENUMERATED, "LBXREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "QueryVersion");
+
+ p = DefineType(LBXEVENT, ENUMERATED, "LBXEVENT", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "SwitchEvent");
+ DefineEValue (p, 1L, "CloseEvent");
+}
diff --git a/decode_randr.c b/decode_randr.c
new file mode 100644
index 0000000..b6a1ce3
--- /dev/null
+++ b/decode_randr.c
@@ -0,0 +1,100 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#define _RANDR_SERVER_
+#include "scope.h"
+#include "x11.h"
+#include "randrscope.h"
+#include "extensions.h"
+
+unsigned char RANDRRequest, RANDRError, RANDREvent;
+
+void
+randr_decode_req (
+ FD fd,
+ const unsigned char *buf)
+{
+ short Major = IByte (&buf[0]);
+ short Minor = IByte (&buf[1]);
+
+ switch (Minor) {
+ case 0: RandrQueryVersion (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 1: RandrGetScreenInfo (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 2: RandrSetScreenConfig (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 3: RandrScreenChangeSelectInput (fd, buf);
+ default:
+ break;
+ }
+}
+
+void
+randr_decode_reply (
+ FD fd,
+ const unsigned char *buf,
+ short RequestMinor)
+{
+ switch (RequestMinor) {
+ case 0: RandrQueryVersionReply (fd, buf); break;
+ case 1: RandrGetScreenInfoReply (fd, buf); break;
+ case 2: RandrSetScreenConfigReply (fd, buf); break;
+ }
+}
+
+void
+randr_decode_event (
+ FD fd,
+ const unsigned char *buf)
+{
+ RandrScreenChangeNotifyEvent (buf);
+}
+
+void
+InitializeRANDR (
+ const unsigned char *buf)
+{
+ TYPE p;
+
+ RANDRRequest = (unsigned char)(buf[9]);
+ RANDREvent = (unsigned char)(buf[10]);
+ RANDRError = (unsigned char)(buf[11]);
+
+ DefineEValue (&TD[REQUEST], (unsigned long) RANDRRequest, "RandrRequest");
+ DefineEValue (&TD[REPLY], (unsigned long) RANDRRequest, "RandrReply");
+ DefineEValue (&TD[EVENT], (unsigned long) RANDREvent, "RRScreenChangeNotify");
+
+ p = DefineType(RANDRREQUEST, ENUMERATED, "RANDRREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 0L, "RandrQueryVersion");
+ DefineEValue(p, 1L, "RandrGetScreenInfo");
+ DefineEValue(p, 2L, "RandrSetScreenConfig");
+ DefineEValue(p, 3L, "RandrScreenChangeSelectInput");
+
+ p = DefineType(RANDRREPLY, ENUMERATED, "RANDRREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "QueryVersion");
+ DefineEValue (p, 1L, "GetScreenInfo");
+ DefineEValue (p, 2L, "SetScreenConfig");
+}
diff --git a/decode_render.c b/decode_render.c
new file mode 100644
index 0000000..e1f5c05
--- /dev/null
+++ b/decode_render.c
@@ -0,0 +1,328 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#define _RENDER_SERVER_
+#include "scope.h"
+#include "x11.h"
+#include "renderscope.h"
+#include "extensions.h"
+
+unsigned char RENDERRequest, RENDERError;
+
+void
+render_decode_req (
+ FD fd,
+ const unsigned char *buf)
+{
+ short Major = IByte (&buf[0]);
+ short Minor = IByte (&buf[1]);
+
+ switch (Minor) {
+ case 0: RenderQueryVersion (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 1: RenderQueryPictFormats (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 2: RenderQueryPictIndexValues (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 3: RenderQueryDithers (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 4: RenderCreatePicture (fd, buf); break;
+ case 5: RenderChangePicture (fd, buf); break;
+ case 6: RenderSetPictureClipRectangles (fd, buf); break;
+ case 7: RenderFreePicture (fd, buf); break;
+ case 8: RenderComposite (fd, buf); break;
+ case 9: RenderScale (fd, buf); break;
+ case 10: RenderTrapezoids (fd, buf); break;
+ case 11: RenderTriangles (fd, buf); break;
+ case 12: RenderTriStrip (fd, buf); break;
+ case 13: RenderTriFan (fd, buf); break;
+ case 14: RenderColorTrapezoids (fd, buf); break;
+ case 15: RenderColorTriangles (fd, buf); break;
+ case 16: RenderTransform (fd, buf); break;
+ case 17: RenderCreateGlyphSet (fd, buf); break;
+ case 18: RenderReferenceGlyphSet (fd, buf); break;
+ case 19: RenderFreeGlyphSet (fd, buf); break;
+ case 20: RenderAddGlyphs (fd, buf); break;
+ case 21: RenderAddGlyphsFromPicture (fd, buf); break;
+ case 22: RenderFreeGlyphs (fd, buf); break;
+ case 23: RenderCompositeGlyphs8 (fd, buf); break;
+ case 24: RenderCompositeGlyphs16 (fd, buf); break;
+ case 25: RenderCompositeGlyphs32 (fd, buf); break;
+ case 26: RenderFillRectangles (fd, buf); break;
+ default:
+ break;
+ }
+}
+
+void
+render_decode_reply (
+ FD fd,
+ const unsigned char *buf,
+ short RequestMinor)
+{
+ switch (RequestMinor) {
+ case 0: RenderQueryVersionReply (fd, buf); break;
+ case 1: RenderQueryPictFormatsReply (fd, buf); break;
+ case 2: RenderQueryPictIndexValuesReply (fd, buf); break;
+ case 3: RenderQueryDithersReply (fd, buf); break;
+ }
+}
+
+void
+render_decode_error (
+ FD fd,
+ const unsigned char *buf)
+{
+ short error = IByte(&buf[1]) - RENDERError;
+
+ switch (error) {
+ case 0: RenderPictFormatError (fd, buf); break;
+ case 1: RenderPictureError (fd, buf); break;
+ case 2: RenderPictOpError (fd, buf); break;
+ case 3: RenderGlyphSetError (fd, buf); break;
+ case 4: RenderGlyphError (fd, buf); break;
+ default:
+ break;
+ }
+}
+
+static int
+PrintPICTURE (
+ const unsigned char *buf)
+{
+ /* print a WINDOW -- CARD32 plus 0 = None */
+ long n = ILong (buf);
+ if (n == 0)
+ fprintf(stdout, "None");
+ else
+ fprintf(stdout, "PICTURE %08lx", n);
+ return(4);
+}
+
+static int
+PrintPICTFORMAT (
+ const unsigned char *buf)
+{
+ /* print a WINDOW -- CARD32 plus 0 = None */
+ long n = ILong (buf);
+ if (n == 0)
+ fprintf(stdout, "None");
+ else
+ fprintf(stdout, "PICTFORMAT %08lx", n);
+ return(4);
+}
+
+static int
+PrintPICTFORMINFO (
+ const unsigned char *buf)
+{
+ /* print a PictFormInfo */
+ long n = ILong(buf);
+ short t = IByte(buf+4);
+ short d = IByte(buf+5);
+
+ fprintf (stdout, "PICTFORMINFO %08lx %s %d ",
+ n, t == 0 ? "Indexed" : "Direct", d);
+ if (t == 0) {
+ long c = ILong(buf+20);
+ fprintf (stdout, "cmap %08lx", c);
+ } else {
+ short r = IShort(buf+8);
+ short g = IShort(buf+12);
+ short b = IShort(buf+16);
+ short a = IShort(buf+20);
+ fprintf (stdout, "%d %d %d %d", a, r, g, b);
+ }
+ return(28);
+}
+
+static int
+PrintGLYPHSET (
+ const unsigned char *buf)
+{
+ /* print a GLYPHSET -- CARD32 plus 0 = None */
+ long n = ILong (buf);
+ if (n == 0)
+ fprintf(stdout, "None");
+ else
+ fprintf(stdout, "GLYPHSET %08lx", n);
+ return(4);
+}
+
+static int
+PrintRENDERCOLOR (
+ const unsigned char *buf)
+{
+ /* print a RENDERCOLOR */
+ unsigned short r, g, b, a;
+
+ r = IShort(buf);
+ g = IShort(buf+2);
+ b = IShort(buf+4);
+ a = IShort(buf+6);
+ fprintf(stdout, "COLOR r:%04x g:%04x b:%04x a:%04x", r, g, b, a);
+ return(8);
+}
+
+static int
+PrintFIXED (
+ const unsigned char *buf)
+{
+ /* print a PICTURE */
+ long n = ILong (buf);
+ fprintf (stdout, "FIXED %7.2f", n / 65536.0);
+ return 4;
+}
+
+static int
+PrintPOINTFIXED (
+ const unsigned char *buf)
+{
+ long x = ILong (buf);
+ long y = ILong (buf+4);
+ fprintf (stdout, "POINT %7.2f, %7.2f", x / 65536.0, y / 65536.0);
+ return 8;
+}
+
+static int
+PrintTRAPEZOID (
+ const unsigned char *buf)
+{
+ /* print a TRAPEZOID */
+ PrintField (buf, 0, 4, FIXED, "top");
+ PrintField (buf, 4, 4, FIXED, "bottom");
+ PrintField (buf, 8, 8, POINTFIXED, "left top");
+ PrintField (buf, 16, 8, POINTFIXED, "left bottom");
+ PrintField (buf, 24, 8, POINTFIXED, "right top");
+ PrintField (buf, 32, 8, POINTFIXED, "right bottom");
+ return 40;
+}
+
+static int
+PrintTRIANGLE (
+ const unsigned char *buf)
+{
+ /* print a TRIANGLE */
+ PrintField (buf, 0, 8, POINTFIXED, "p1");
+ PrintField (buf, 8, 8, POINTFIXED, "p2");
+ PrintField (buf,16, 8, POINTFIXED, "p3");
+ return 24;
+}
+
+void
+InitializeRENDER (
+ const unsigned char *buf)
+{
+ TYPE p;
+
+ RENDERRequest = (unsigned char)(buf[9]);
+ RENDERError = (unsigned char)(buf[11]);
+
+ DefineEValue (&TD[REQUEST], (unsigned long) RENDERRequest, "RenderRequest");
+ DefineEValue (&TD[REPLY], (unsigned long) RENDERRequest, "RenderReply");
+
+ DefineEValue (&TD[ERROR], (unsigned long) RENDERError + 0, "BadPictFormat");
+ DefineEValue (&TD[ERROR], (unsigned long) RENDERError + 1, "BadPicture");
+ DefineEValue (&TD[ERROR], (unsigned long) RENDERError + 2, "BadPictOp");
+ DefineEValue (&TD[ERROR], (unsigned long) RENDERError + 3, "BadGlyphSet");
+ DefineEValue (&TD[ERROR], (unsigned long) RENDERError + 4, "BadGlyph");
+
+ p = DefineType(RENDERREQUEST, ENUMERATED, "RENDERREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 0L, "RenderQueryVersion");
+ DefineEValue(p, 1L, "RenderQueryPictFormats");
+ DefineEValue(p, 2L, "RenderQueryPictIndexValues");
+ DefineEValue(p, 3L, "RenderQueryDithers");
+ DefineEValue(p, 4L, "RenderCreatePicture");
+ DefineEValue(p, 5L, "RenderChangePicture");
+ DefineEValue(p, 6L, "RenderSetPictureClipRectangles");
+ DefineEValue(p, 7L, "RenderFreePicture");
+ DefineEValue(p, 8L, "RenderComposite");
+ DefineEValue(p, 9L, "RenderScale");
+ DefineEValue(p, 10L, "RenderTrapezoids");
+ DefineEValue(p, 11L, "RenderTriangles");
+ DefineEValue(p, 12L, "RenderTriStrip");
+ DefineEValue(p, 13L, "RenderTriFan");
+ DefineEValue(p, 14L, "RenderColorTrapezoids");
+ DefineEValue(p, 15L, "RenderColorTriangles");
+ DefineEValue(p, 16L, "RenderTransform");
+ DefineEValue(p, 17L, "RenderCreateGlyphSet");
+ DefineEValue(p, 18L, "RenderReferenceGlyphSet");
+ DefineEValue(p, 19L, "RenderFreeGlyphSet");
+ DefineEValue(p, 20L, "RenderAddGlyphs");
+ DefineEValue(p, 21L, "RenderAddGlyphsFromPicture");
+ DefineEValue(p, 22L, "RenderFreeGlyphs");
+ DefineEValue(p, 23L, "RenderCompositeGlyphs8");
+ DefineEValue(p, 24L, "RenderCompositeGlyphs16");
+ DefineEValue(p, 25L, "RenderCompositeGlyphs32");
+ DefineEValue(p, 26L, "RenderFillRectangles");
+
+ p = DefineType(RENDERREPLY, ENUMERATED, "RENDERREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "QueryVersion");
+ DefineEValue (p, 1L, "QueryPictFormats");
+ DefineEValue (p, 2L, "QueryPictIndexValues");
+ DefineEValue (p, 3L, "QueryDithers");
+
+ DefineType(PICTURE, BUILTIN, "PICTURE", PrintPICTURE);
+ DefineType(PICTFORMAT, BUILTIN, "PICTFORMAT", PrintPICTFORMAT);
+ DefineType(GLYPHSET, BUILTIN, "GLYPHSET", PrintGLYPHSET);
+ DefineType(RENDERCOLOR, BUILTIN, "RENDERCOLOR", PrintRENDERCOLOR);
+ DefineType(PICTFORMINFO, BUILTIN, "PICTFORMINFO", PrintPICTFORMINFO);
+
+ p = DefineType(PICTURE_BITMASK, SET, "PICTURE_BITMASK", (PrintProcType) PrintSET);
+
+ DefineValues(p, 0x00000001L, 1, BOOL, "repeat");
+ DefineValues(p, 0x00000002L, 1, PICTURE, "alpha-map");
+ DefineValues(p, 0x00000004L, 1, INT16, "alpha-x-origin");
+ DefineValues(p, 0x00000008L, 1, INT16, "alpha-y-origin");
+ DefineValues(p, 0x00000010L, 1, INT16, "clip-x-origin");
+ DefineValues(p, 0x00000020L, 1, INT16, "clip-y-origin");
+ DefineValues(p, 0x00000040L, 1, PIXMAP, "clip-mask");
+ DefineValues(p, 0x00000080L, 1, BOOL, "graphics-exposures");
+ DefineValues(p, 0x00000100L, 1, SUBWINMODE, "repeat");
+ DefineValues(p, 0x00000200L, 1, BOOL, "poly-edge");
+ DefineValues(p, 0x00000400L, 1, BOOL, "poly-mode");
+ DefineValues(p, 0x00000800L, 1, ATOM, "dither");
+ DefineValues(p, 0x00001000L, 1, BOOL, "component-alpha");
+
+ p = DefineType(PICTOP, ENUMERATED, "PICTOP", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "Clear");
+ DefineEValue (p, 1L, "Src");
+ DefineEValue (p, 2L, "Dst");
+ DefineEValue (p, 3L, "Over");
+ DefineEValue (p, 4L, "OverReverse");
+ DefineEValue (p, 5L, "In");
+ DefineEValue (p, 6L, "InReverse");
+ DefineEValue (p, 7L, "Out");
+ DefineEValue (p, 8L, "OutReverse");
+ DefineEValue (p, 9L, "Atop");
+ DefineEValue (p, 10L, "AtopReverse");
+ DefineEValue (p, 11L, "Xor");
+ DefineEValue (p, 12L, "Add");
+ DefineEValue (p, 13L, "Saturate");
+
+ DefineType(FIXED, BUILTIN, "FIXED", PrintFIXED);
+ DefineType(POINTFIXED, BUILTIN, "POINTFIXED", PrintPOINTFIXED);
+ DefineType(TRIANGLE, RECORD, "TRIANGLE", PrintTRIANGLE);
+ DefineType(TRAPEZOID, RECORD, "TRAPEZOID", PrintTRAPEZOID);
+}
diff --git a/decode_shm.c b/decode_shm.c
new file mode 100644
index 0000000..938c770
--- /dev/null
+++ b/decode_shm.c
@@ -0,0 +1,119 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "scope.h"
+#include "x11.h"
+#include "shmscope.h"
+#include "extensions.h"
+
+unsigned char MITSHMRequest, MITSHMError, MITSHMEvent;
+
+void
+mitshm_decode_req (
+ FD fd,
+ const unsigned char *buf)
+{
+ short Major = IByte (&buf[0]);
+ short Minor = IByte (&buf[1]);
+
+ switch (Minor) {
+ case 0: MitshmQueryVersion (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 1: MitshmAttach (fd, buf); break;
+ case 2: MitshmDetach (fd, buf); break;
+ case 3: MitshmPutImage (fd, buf); break;
+ case 4: MitshmGetImage (fd, buf); ExtendedReplyExpected (fd, Major, Minor); break;
+ case 5: MitshmCreatePixmap (fd, buf); break;
+ default:
+ break;
+ }
+}
+
+void
+mitshm_decode_reply (
+ FD fd,
+ const unsigned char *buf,
+ short RequestMinor)
+{
+ switch (RequestMinor) {
+ case 0: MitshmQueryVersionReply (fd, buf); break;
+ case 4: MitshmGetImageReply (fd, buf); break;
+ }
+}
+
+void
+mitshm_decode_event (
+ FD fd,
+ const unsigned char *buf)
+{
+}
+
+void
+mitshm_decode_error (
+ FD fd,
+ const unsigned char *buf)
+{
+ short error = IByte(&buf[0]) - MITSHMError;
+
+ switch (error) {
+ case 0: MitshmShmSegError (fd, buf); break;
+ default:
+ break;
+ }
+}
+
+
+void
+InitializeMITSHM (
+ const unsigned char *buf)
+{
+ TYPE p;
+
+ MITSHMRequest = (unsigned char)(buf[9]);
+ MITSHMEvent = (unsigned char)(buf[10]);
+ MITSHMError = (unsigned char)(buf[11]);
+
+ DefineEValue (&TD[REQUEST], (unsigned long) MITSHMRequest, "MitshmRequest");
+ DefineEValue (&TD[REPLY], (unsigned long) MITSHMRequest, "MitshmReply");
+ DefineEValue (&TD[EVENT], (unsigned long) MITSHMEvent, "MitshmEvent");
+ DefineEValue (&TD[ERROR], (unsigned long) MITSHMError, "MitshmError");
+
+ p = DefineType(MITSHMREQUEST, ENUMERATED, "MITSHMREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 0L, "MitshmQueryVersion");
+ DefineEValue(p, 1L, "MitshmAttach");
+ DefineEValue(p, 2L, "MitshmDetach");
+ DefineEValue(p, 3L, "MitshmPutImage");
+ DefineEValue(p, 4L, "MitshmGetImage");
+ DefineEValue(p, 5L, "MitshmCreatePixmap");
+
+ p = DefineType(MITSHMREPLY, ENUMERATED, "MITSHMREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "QueryVersion");
+ DefineEValue (p, 4L, "GetImage");
+
+ p = DefineType(MITSHMEVENT, ENUMERATED, "MITSHMEVENT", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "CompletionEvent");
+}
diff --git a/decode_wcp.c b/decode_wcp.c
new file mode 100644
index 0000000..fdb7664
--- /dev/null
+++ b/decode_wcp.c
@@ -0,0 +1,132 @@
+/*
+ * $NCDOr$
+ *
+ * Copyright 1996 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#define _WCP_SERVER_
+#include "scope.h"
+#include "x11.h"
+#include "wcpscope.h"
+#include "extensions.h"
+
+unsigned char WCPRequest, WCPError;
+
+void
+wcp_decode_req (
+ FD fd,
+ const unsigned char *buf)
+{
+ short Major = IByte (&buf[0]);
+ short Minor = IByte (&buf[1]);
+
+ switch (Minor) {
+ case 0:
+ WcpQueryVersion (fd, buf);
+ ExtendedReplyExpected (fd, Major, Minor);
+ break;
+ case 1:
+ WcpPutImage (fd, buf);
+ break;
+ case 2:
+ WcpGetImage (fd, buf);
+ ExtendedReplyExpected (fd, Major, Minor);
+ break;
+ case 3:
+ WcpCreateColorCursor (fd, buf);
+ break;
+ case 4:
+ WcpCreateLut (fd, buf);
+ break;
+ case 5:
+ WcpFreeLut (fd, buf);
+ break;
+ case 6:
+ WcpCopyArea (fd, buf);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+wcp_decode_reply (
+ FD fd,
+ const unsigned char *buf,
+ short RequestMinor)
+{
+ switch (RequestMinor) {
+ case 0:
+ WcpQueryVersionReply (fd, buf);
+ break;
+ case 2:
+ WcpGetImageReply (fd, buf);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+wcp_decode_error (
+ FD fd,
+ const unsigned char *buf)
+{
+ short error = IByte(&buf[1]) - WCPError;
+
+ switch (error) {
+ case 0:
+ break;
+ default:
+ break;
+ }
+}
+
+void
+InitializeWCP (
+ const unsigned char *buf)
+{
+ TYPE p;
+
+ WCPRequest = (unsigned char)(buf[9]);
+ WCPError = (unsigned char)(buf[11]);
+
+ DefineEValue (&TD[REQUEST], (unsigned long) WCPRequest, "WcpRequest");
+ DefineEValue (&TD[REPLY], (unsigned long) WCPRequest, "WcpReply");
+ DefineEValue (&TD[ERROR], (unsigned long) WCPError, "WcpError");
+
+ p = DefineType(WCPREQUEST, ENUMERATED, "WCPREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 0L, "WcpQueryVersion");
+ DefineEValue(p, 1L, "WcpPutImage");
+ DefineEValue(p, 2L, "WcpGetImage");
+ DefineEValue(p, 3L, "WcpCreateColorCursor");
+ DefineEValue(p, 4L, "WcpCreateLut");
+ DefineEValue(p, 5L, "WcpFreeLut");
+ DefineEValue(p, 6L, "WcpCopyArea");
+
+ p = DefineType(WCPREPLY, ENUMERATED, "WCPREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 0L, "QueryVersion");
+
+}
diff --git a/decodenas.c b/decodenas.c
new file mode 100644
index 0000000..befa2eb
--- /dev/null
+++ b/decodenas.c
@@ -0,0 +1,470 @@
+/* ************************************************************ *
+ * *
+ * Decoding and switching routines for the NAS protocol *
+ * *
+ * James Peterson, 1988 *
+ * (c) Copyright MCC, 1988 *
+ * *
+ * ************************************************************ */
+
+#include "scope.h"
+#include "nas.h"
+
+/*
+ There are 4 types of things in NAS: requests, replies, errors, and events.
+
+ Each of them has a format defined by a small integer that defines
+ the type of the thing.
+
+ Requests have an opcode in the first byte.
+ Events have a code in the first byte.
+ Errors have a code in the second byte (the first byte is 0)
+ Replies ...
+
+ Replies have a sequence number in bytes 2 and 3. The sequence
+ number should be used to identify the request that was sent, and
+ from that request we can determine the type of the reply.
+*/
+
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+
+/*
+ We need to keep the sequence number for a request to match it with
+ an expected reply. The sequence number is associated only with the
+ particular connection that we have. We would expect these replies
+ to be handled as a FIFO queue.
+*/
+
+#define DUMP_REQUEST 0
+#define DUMP_REPLY 1
+#define DUMP_EVENT 2
+#define DUMP_ERROR 3
+
+static const char * const simple_names[] = {
+ "REQUEST",
+ "REPLY ",
+ "EVENT ",
+ "ERROR ",
+};
+
+static void
+AudioSimpleDump (int type, FD fd, short Major, short Minor, long bytes)
+{
+ PrintTime ();
+ fprintf (stdout, "@@%s %3d %3d %3d %7ld\n",
+ simple_names[type],
+ ClientNumber(fd),
+ Major, Minor, bytes);
+}
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+void
+DecodeAudioRequest(
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short Request = IByte (&buf[0]);
+ short RequestMinor = Request >= 128 ? IByte (&buf[1]) : 0;
+ unsigned long seq;
+
+ CS[fd].SequenceNumber += 1;
+ seq = CS[fd].SequenceNumber;
+ if (CS[fd].littleEndian) {
+ SBf[0] = seq;
+ SBf[1] = seq >> 8;
+ SBf[2] = seq >> 16;
+ SBf[3] = seq >> 24;
+ } else {
+ SBf[0] = seq >> 24;
+ SBf[1] = seq >> 16;
+ SBf[2] = seq >> 8;
+ SBf[3] = seq;
+ }
+ SetIndentLevel(PRINTCLIENT);
+
+ if (NasVerbose == 0)
+ {
+ AudioSimpleDump (DUMP_REQUEST, fd, Request, RequestMinor, n);
+ return;
+ }
+
+ if (NasVerbose > 3)
+ DumpItem("Request", fd, buf, n);
+ switch (Request)
+ {
+ case 1:
+ AudioListDevices (buf);
+ ReplyExpected(fd, Request);
+ break;
+ case 2:
+ AudioGetDeviceAttributes(buf);
+ ReplyExpected(fd, Request);
+ break;
+ case 3:
+ AudioSetDeviceAttributes (buf);
+ break;
+ case 4:
+ AudioCreateBucket (buf);
+ break;
+ case 5:
+ AudioDestroyBucket (buf);
+ break;
+ case 6:
+ AudioListBuckets (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 7:
+ AudioGetBucketAttributes (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 8:
+ AudioSetBucketAttributes (buf);
+ break;
+ case 9:
+ AudioCreateRadio (buf);
+ break;
+ case 10:
+ AudioDestroyRadio (buf);
+ break;
+ case 11:
+ AudioListRadios (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 12:
+ AudioGetRadioAttributes (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 13:
+ AudioSetRadioAttributes (buf);
+ break;
+ case 14:
+ AudioCreateFlow (buf);
+ break;
+ case 15:
+ AudioDestroyFlow (buf);
+ break;
+ case 16:
+ AudioGetFlowAttributes (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 17:
+ AudioSetFlowAttributes (buf);
+ break;
+ case 18:
+ AudioGetElements (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 19:
+ AudioSetElements (buf);
+ break;
+ case 20:
+ AudioGetElementStates (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 21:
+ AudioSetElementStates (buf);
+ break;
+ case 22:
+ AudioGetElementParameters (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 23:
+ AudioSetElementParameters (buf);
+ break;
+ case 24:
+ AudioWriteElement (buf);
+ break;
+ case 25:
+ AudioReadElement (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 26:
+ AudioGrabComponent (buf);
+ break;
+ case 27:
+ AudioUngrabComponent (buf);
+ break;
+ case 28:
+ AudioSendEvent (buf);
+ break;
+ case 29:
+ AudioGetAllowedUsers (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 30:
+ AudioSetAllowedUsers (buf);
+ break;
+ case 31:
+ AudioListExtensions (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 32:
+ AudioQueryExtension (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 33:
+ AudioGetCloseDownMode (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 34:
+ AudioSetCloseDownMode (buf);
+ break;
+ case 35:
+ AudioKillClient (buf);
+ break;
+ case 36:
+ AudioGetServerTime (buf);
+ ReplyExpected (fd, Request);
+ break;
+ case 37:
+ AudioNoOperation (buf);
+ break;
+ default:
+ warn("Unimplemented request opcode");
+ break;
+ }
+}
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+void
+DecodeAudioReply(
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short SequenceNumber = IShort (&buf[2]);
+ short RequestMinor;
+ short Request = CheckReplyTable (fd, SequenceNumber, &RequestMinor);
+
+ if (NasVerbose == 0)
+ {
+ AudioSimpleDump (DUMP_REPLY, fd, Request, RequestMinor, n);
+ return;
+ }
+
+ SetIndentLevel(PRINTSERVER);
+ RBf[0] = Request /* for the PrintField in the Reply procedure */ ;
+ RBf[1] = RequestMinor;
+ if (NasVerbose > 3)
+ DumpItem("Reply", fd, buf, n);
+ switch (Request)
+ {
+ case 0:
+ UnknownAudioReply(buf);
+ break;
+ case 1:
+ AudioListDevicesReply (buf);
+ break;
+ case 2:
+ AudioGetDeviceAttributesReply (buf);
+ break;
+ case 6:
+ AudioListBucketsReply (buf);
+ break;
+ case 7:
+ AudioGetBucketAttributesReply (buf);
+ break;
+ case 11:
+ AudioListRadiosReply (buf);
+ break;
+ case 12:
+ AudioGetRadioAttributesReply (buf);
+ break;
+ case 16:
+ AudioGetFlowAttributesReply (buf);
+ break;
+ case 18:
+ AudioGetElementsReply (buf);
+ break;
+ case 20:
+ AudioGetElementStatesReply (buf);
+ break;
+ case 22:
+ AudioGetElementParametersReply (buf);
+ break;
+ case 25:
+ AudioReadElementReply (buf);
+ break;
+ case 29:
+ AudioGetAllowedUsersReply (buf);
+ break;
+ case 31:
+ AudioListExtensionsReply (buf);
+ break;
+ case 32:
+ AudioQueryExtensionReply (buf);
+ break;
+ case 33:
+ AudioGetCloseDownModeReply (buf);
+ break;
+ case 36:
+ AudioGetServerTimeReply (buf);
+ break;
+ default:
+ warn("Unimplemented reply opcode");
+ break;
+ }
+}
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+void
+DecodeAudioError(
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short Error = IByte (&buf[1]);
+ short Request = 0;
+ short RequestMinor = 0;
+
+ Request = CheckReplyTable (fd, (short)IShort(&buf[2]), &RequestMinor);
+
+ if (NasVerbose == 0)
+ {
+ AudioSimpleDump (DUMP_ERROR, fd, Request, RequestMinor, n);
+ return;
+ }
+
+ SetIndentLevel(PRINTSERVER);
+ if (NasVerbose > 3)
+ DumpItem("Error", fd, buf, n);
+}
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+void
+DecodeAudioEvent(
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ short Event = IByte (&buf[0]);
+ short EventMinor = 0;
+
+ if (NasVerbose == 0)
+ {
+ AudioSimpleDump (DUMP_EVENT, fd, Event, EventMinor, n);
+ return;
+ }
+
+ SetIndentLevel(PRINTSERVER);
+ if (NasVerbose > 3)
+ DumpItem("Event", fd, buf, n);
+ /* high-order bit means SendEvent generated */
+ if (Event & 0x80)
+ {
+ debug(8,(stderr, "SendEvent generated event 0x%x\n", Event));
+ Event = Event & 0x7F;
+ }
+ switch (Event)
+ {
+ case 2:
+ AudioElementNotify (buf);
+ break;
+ case 3:
+ AudioGrabNotify (buf);
+ break;
+ case 4:
+ AudioMonitorNotify (buf);
+ break;
+ case 5:
+ AudioBucketNotify (buf);
+ break;
+ case 6:
+ AudioDeviceNotify (buf);
+ break;
+ default:
+ warn("Unimplemented event code");
+ break;
+ }
+}
+
+void
+InitializeAudioDecode (void)
+{
+ TYPE p;
+
+ p = DefineType (NASREQUEST, ENUMERATED, "NASREQUEST", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 1L, "ListDevices");
+ DefineEValue (p, 2L, "GetDeviceAttributes");
+ DefineEValue (p, 3L, "SetDeviceAttributes");
+ DefineEValue (p, 4L, "CreateBucket");
+ DefineEValue (p, 5L, "DestroyBucket");
+ DefineEValue (p, 6L, "ListBuckets");
+ DefineEValue (p, 7L, "GetBucketAttributes");
+ DefineEValue (p, 8L, "SetBucketAttributes");
+ DefineEValue (p, 9L, "CreateRadio");
+ DefineEValue (p, 10L, "DestroyRadio");
+ DefineEValue (p, 11L, "ListRadios");
+ DefineEValue (p, 12L, "GetRadioAttributes");
+ DefineEValue (p, 13L, "SetRadioAttributes");
+ DefineEValue (p, 14L, "CreateFlow");
+ DefineEValue (p, 15L, "DestroyFlow");
+ DefineEValue (p, 16L, "GetFlowAttributes");
+ DefineEValue (p, 17L, "SetFlowAttributes");
+ DefineEValue (p, 18L, "GetElements");
+ DefineEValue (p, 19L, "SetElements");
+ DefineEValue (p, 20L, "GetElementStates");
+ DefineEValue (p, 21L, "SetElementStates");
+ DefineEValue (p, 22L, "GetElementParameters");
+ DefineEValue (p, 23L, "SetElementParameters");
+ DefineEValue (p, 24L, "WriteElement");
+ DefineEValue (p, 25L, "ReadElement");
+ DefineEValue (p, 26L, "GrabComponent");
+ DefineEValue (p, 27L, "UngrabComponent");
+ DefineEValue (p, 28L, "SendEvent");
+ DefineEValue (p, 29L, "GetAllowedUsers");
+ DefineEValue (p, 30L, "SetAllowedUsers");
+ DefineEValue (p, 31L, "ListExtensions");
+ DefineEValue (p, 32L, "QuerExtension");
+ DefineEValue (p, 33L, "GetCloseDownMode");
+ DefineEValue (p, 34L, "SetCloseDownMode");
+ DefineEValue (p, 35L, "KillClient");
+ DefineEValue (p, 36L, "GetServerTime");
+ DefineEValue (p, 37L, "NoOperation");
+ p = DefineType (NASREPLY, ENUMERATED, "NASREPLY", (PrintProcType) PrintENUMERATED);
+ DefineEValue (p, 1L, "ListDevices");
+ DefineEValue (p, 2L, "GetDeviceAttributes");
+ DefineEValue (p, 6L, "ListBuckets");
+ DefineEValue (p, 7L, "GetBucketAttributes");
+ DefineEValue (p, 11L, "ListRadios");
+ DefineEValue (p, 12L, "GetRadioAttributes");
+ DefineEValue (p, 16L, "GetFlowAttributes");
+ DefineEValue (p, 18L, "GetElements");
+ DefineEValue (p, 20L, "GetElementStates");
+ DefineEValue (p, 22L, "GetElementParameters");
+ DefineEValue (p, 25L, "ReadElement");
+ DefineEValue (p, 29L, "GetAllowedUsers");
+ DefineEValue (p, 31L, "ListExtensions");
+ DefineEValue (p, 32L, "QueryExtension");
+ DefineEValue (p, 33L, "GetCloseDownMode");
+ DefineEValue (p, 36L, "GetServerTime");
+ p = DefineType (NASEVENT, ENUMERATED, "NASEVENT", (PrintProcType) PrintENUMERATED);
+ DefineEValue(p, 2L, "ElementNotify");
+ DefineEValue(p, 3L, "GrabNotify");
+ DefineEValue(p, 4L, "MonitorNotify");
+ DefineEValue(p, 5L, "BucketNotify");
+ DefineEValue(p, 6L, "DeviceNotify");
+
+}
diff --git a/extensions.c b/extensions.c
new file mode 100644
index 0000000..d053c06
--- /dev/null
+++ b/extensions.c
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, and/or sell copies of the Software, and to permit persons
+ * to whom the Software is furnished to do so, provided that the above
+ * copyright notice(s) and this permission notice appear in all copies of
+ * the Software and that both the above copyright notice(s) and this
+ * permission notice appear in supporting documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+ * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder
+ * shall not be used in advertising or otherwise to promote the sale, use
+ * or other dealings in this Software without prior written authorization
+ * of the copyright holder.
+ */
+
+#include "extensions.h"
+#include "bigreqscope.h"
+#include "lbxscope.h"
+#include "randrscope.h"
+#include "renderscope.h"
+#include "shmscope.h"
+#include "wcpscope.h"
+
+/* Extensions we know how to decode */
+struct extension_decoders {
+ const char *name;
+ void (*init_func)(const unsigned char *buf);
+};
+
+static const struct extension_decoders decodable_extensions[] = {
+ { "BIG-REQUESTS", InitializeBIGREQ },
+ { "LBX", InitializeLBX },
+ { "MITSHM", InitializeMITSHM },
+ { "NCD-WinCenterPro", InitializeWCP },
+ { "RANDR", InitializeRANDR },
+ { "RENDER", InitializeRENDER },
+ { NULL, NULL } /* List terminator - keep last */
+};
+
+/* all extensions we know about */
+struct extension_info {
+ const char *name;
+ unsigned char request;
+ unsigned char event;
+ unsigned char error;
+ long query_seq; /* sequence id of QueryExtension request */
+ struct extension_info *next;
+};
+
+struct extension_info *query_list;
+
+struct extension_info *ext_by_request[NUM_EXTENSIONS];
+
+static void
+DefineExtNameValue(int type, unsigned char value, const char *extname)
+{
+ int namelen = strlen(extname) + 1;
+ const char *typename = NULL;
+ char *exttypename;
+
+ switch (type) {
+ case REQUEST:
+ typename = "-Request";
+ break;
+ case REPLY:
+ typename = "-Reply";
+ break;
+ case EVENT:
+ typename = "-Event";
+ break;
+ case ERROR:
+ typename = "-Error";
+ break;
+ default:
+ panic("Impossible argument to DefineExtNameValue");
+ }
+ namelen += strlen(typename);
+ exttypename = Malloc(namelen);
+ snprintf(exttypename, namelen, "%s%s", extname, typename);
+ DefineEValue(&TD[type], (unsigned long) value, exttypename);
+}
+
+void
+ProcessQueryExtensionRequest(long seq, const unsigned char *buf)
+{
+ int namelen = IShort(&buf[4]);
+ char *extname = Malloc(namelen + 1);
+ struct extension_info *qe;
+
+ memcpy(extname, &buf[8], namelen);
+ extname[namelen] = '\0';
+
+ for (qe = query_list; qe != NULL; qe = qe->next) {
+ if (strcmp(extname, qe->name) == 0) {
+ /* already in list, no need to add */
+ Free(extname);
+ return;
+ }
+ }
+
+ /* add to list */
+ qe = Malloc(sizeof(struct extension_info));
+ qe->name = extname;
+ qe->request = 0;
+ qe->event = 0;
+ qe->error = 0;
+ qe->query_seq = seq;
+ qe->next = query_list;
+ query_list = qe;
+}
+
+void
+ProcessQueryExtensionReply(long seq, const unsigned char *buf)
+{
+ struct extension_info *qe;
+ int i;
+
+ for (qe = query_list; qe != NULL; qe = qe->next) {
+ if (qe->query_seq == seq) {
+ qe->request = buf[9];
+ qe->event = buf[10];
+ qe->error = buf[11];
+
+ ext_by_request[qe->request - EXTENSION_MIN] = qe;
+
+ for (i = 0; decodable_extensions[i].name != NULL ; i++) {
+ if (strcmp(qe->name, decodable_extensions[i].name) == 0) {
+ decodable_extensions[i].init_func(buf);
+ break;
+ }
+ }
+ if (decodable_extensions[i].name == NULL) {
+ /* Not found - initialize values as best we can generically */
+ DefineExtNameValue(REQUEST, qe->request, qe->name);
+ DefineExtNameValue(REPLY, qe->request, qe->name);
+ if (qe->event != 0) {
+ DefineExtNameValue(EVENT, qe->event, qe->name);
+ }
+ if (qe->error != 0) {
+ DefineExtNameValue(ERROR, qe->error, qe->name);
+ }
+ }
+
+ return;
+ }
+ }
+}
+
+void
+ExtensionRequest (FD fd, const unsigned char *buf, short Request)
+{
+ if (Request == LBXRequest) {
+ lbx_decode_req(fd, buf);
+ } else if (Request == WCPRequest) {
+ wcp_decode_req(fd, buf);
+ } else if (Request == RENDERRequest) {
+ render_decode_req(fd,buf);
+ } else if (Request == RANDRRequest) {
+ randr_decode_req(fd,buf);
+ } else if (Request == MITSHMRequest) {
+ mitshm_decode_req(fd,buf);
+ } else if (Request == BIGREQRequest) {
+ bigreq_decode_req(fd,buf);
+ } else {
+ ExtendedRequest(fd, buf);
+ ReplyExpected(fd, Request);
+ }
+}
+
+void
+ExtensionReply (FD fd, const unsigned char *buf,
+ short Request, short RequestMinor)
+{
+ if (Request == LBXRequest) {
+ lbx_decode_reply(fd, buf, RequestMinor);
+ } else if (Request == WCPRequest) {
+ wcp_decode_reply(fd, buf, RequestMinor);
+ } else if (Request == RENDERRequest) {
+ render_decode_reply(fd, buf, RequestMinor);
+ } else if (Request == RANDRRequest) {
+ randr_decode_reply(fd, buf, RequestMinor);
+ } else if (Request == MITSHMRequest) {
+ mitshm_decode_reply(fd, buf, RequestMinor);
+ } else if (Request == BIGREQRequest) {
+ bigreq_decode_reply(fd, buf, RequestMinor);
+ } else {
+ warn("Extended reply opcode");
+ }
+}
+
+void
+ExtensionError (FD fd, const unsigned char *buf, short Error)
+{
+ if (Error == LBXError) {
+ lbx_decode_error(fd, buf);
+ } else if (Error == WCPError) {
+ wcp_decode_error(fd, buf);
+ } else if (Error >= RENDERError && Error < RENDERError + RENDERNError) {
+ render_decode_error(fd,buf);
+ } else if (Error == MITSHMError) {
+ mitshm_decode_error(fd, buf);
+ } else {
+ warn("Extended Error code");
+ }
+}
+
+void
+ExtensionEvent (FD fd, const unsigned char *buf, short Event)
+{
+ if (Event == LBXEvent) {
+ lbx_decode_event (fd, buf);
+ } else if (Event == RANDREvent) {
+ randr_decode_event (fd, buf);
+ } else if (Event == MITSHMEvent) {
+ mitshm_decode_event (fd, buf);
+ } else {
+ warn("Extended Event code");
+ }
+}
diff --git a/extensions.h b/extensions.h
new file mode 100644
index 0000000..18107e8
--- /dev/null
+++ b/extensions.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, and/or sell copies of the Software, and to permit persons
+ * to whom the Software is furnished to do so, provided that the above
+ * copyright notice(s) and this permission notice appear in all copies of
+ * the Software and that both the above copyright notice(s) and this
+ * permission notice appear in supporting documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+ * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder
+ * shall not be used in advertising or otherwise to promote the sale, use
+ * or other dealings in this Software without prior written authorization
+ * of the copyright holder.
+ */
+
+#ifndef XSCOPE_EXTENSIONS_H
+#define XSCOPE_EXTENSIONS_H
+
+#include "scope.h"
+
+#define EXTENSION_MIN 128 /* lowest possible extension request code */
+#define EXTENSION_MAX 255 /* highest possible extension request code */
+#define NUM_EXTENSIONS 128 /* maximum possible number of extensions */
+
+/* special processing in extensions.c to capture extension info */
+extern void ProcessQueryExtensionRequest(long seq, const unsigned char *buf);
+extern void ProcessQueryExtensionReply(long seq, const unsigned char *buf);
+
+extern void ExtensionRequest(FD fd, const unsigned char *buf, short Request);
+extern void ExtensionReply(FD fd, const unsigned char *buf,
+ short Request, short RequestMinor);
+extern void ExtensionError(FD fd, const unsigned char *buf, short Error);
+extern void ExtensionEvent(FD fd, const unsigned char *buf, short Event);
+
+
+/* X11 Extension decoders in decode_*.c */
+#define extension_decode_prototypes(ext) \
+ extern void ext##_decode_req (FD fd, const unsigned char *buf); \
+ extern void ext##_decode_reply (FD fd, const unsigned char *buf, \
+ short RequestMinor); \
+ extern void ext##_decode_error (FD fd, const unsigned char *buf); \
+ extern void ext##_decode_event (FD fd, const unsigned char *buf)
+
+extension_decode_prototypes(bigreq);
+extension_decode_prototypes(lbx);
+extension_decode_prototypes(mitshm);
+extension_decode_prototypes(randr);
+extension_decode_prototypes(render);
+extension_decode_prototypes(wcp);
+
+extern void InitializeBIGREQ (const unsigned char *buf);
+extern void InitializeLBX (const unsigned char *buf);
+extern void InitializeMITSHM (const unsigned char *buf);
+extern void InitializeRANDR (const unsigned char *buf);
+extern void InitializeRENDER (const unsigned char *buf);
+extern void InitializeWCP (const unsigned char *buf);
+
+#endif /* XSCOPE_EXTENSIONS_H */
diff --git a/fd.c b/fd.c
index 616dc9c..69a00ee 100644
--- a/fd.c
+++ b/fd.c
@@ -53,6 +53,9 @@
*
\* *********************************************************** */
+#include <X11/Xpoll.h> /* for XFD_* macros - must come before
+ scope.h include to avoid INT32 clash */
+
#include "scope.h"
#ifdef SYSV
@@ -62,6 +65,20 @@
#define bcopy(s,d,l) memmove(d,s,l)
#endif
+#include <sys/uio.h> /* for struct iovec, used by socket.h */
+#include <sys/socket.h> /* for AF_INET, SOCK_STREAM, ... */
+#include <sys/ioctl.h> /* for FIONCLEX, FIONBIO, ... */
+#ifdef SVR4
+#include <sys/filio.h>
+#endif
+#include <fcntl.h>
+#include <netinet/in.h> /* struct sockaddr_in */
+#include <sys/un.h> /* struct sockaddr_un */
+#include <netinet/tcp.h>
+#include <netdb.h> /* struct servent * and struct hostent * */
+#include <errno.h> /* for EINTR, EADDRINUSE, ... */
+
+
/*
All of this code is to support the handling of file descriptors (FD).
The idea is to keep a table of the FDs that are in use and why.
@@ -77,16 +94,25 @@
/* ************************************************************ */
void
-InitializeFD()
+InitializeFD(void)
{
register short i;
enterprocedure("InitializeFD");
/* get the number of file descriptors the system will let us use */
+#if defined(hpux) || defined(SVR4)
+ MaxFD = _NFILE - 1;
+#else
MaxFD = getdtablesize();
if (MaxFD > FD_SETSIZE) {
MaxFD = FD_SETSIZE;
}
+#endif
+ if (MaxFD > StaticMaxFD)
+ {
+ fprintf(stderr, "Recompile with larger StaticMaxFD value %d\n", MaxFD);
+ MaxFD = StaticMaxFD;
+ }
/* allocate space for a File Descriptor (FD) Table */
FDD = (struct FDDescriptor *)
@@ -113,18 +139,19 @@ InitializeFD()
FD_ZERO(&ReadDescriptors);
HighestFD = 0;
- UsingFD(fileno(stdin), (void (*)(int))NULL, NULL);
- UsingFD(fileno(stdout), (void (*)(int))NULL, NULL);
- UsingFD(fileno(stderr), (void (*)(int))NULL, NULL);
+ UsingFD(fileno(stdin), NULL, NULL, NULL);
+ UsingFD(fileno(stdout), NULL, NULL, NULL);
+ UsingFD(fileno(stderr), NULL, NULL, NULL);
}
/* ************************************************************ */
void
-UsingFD(fd, Handler, trans_conn)
- FD fd;
- void (*Handler)(int);
- XtransConnInfo trans_conn;
+UsingFD(
+ FD fd,
+ void (*Handler)(int),
+ void (*FlushHandler)(int),
+ XtransConnInfo trans_conn)
{
if (FDD[fd].Busy)
NotUsingFD(fd);
@@ -132,6 +159,7 @@ UsingFD(fd, Handler, trans_conn)
FDD[fd].Busy = true;
FDD[fd].InputHandler = Handler;
+ FDD[fd].FlushHandler = FlushHandler;
#ifdef USE_XTRANS
FDD[fd].trans_conn = trans_conn;
#endif
@@ -152,8 +180,8 @@ UsingFD(fd, Handler, trans_conn)
/* ************************************************************ */
void
-NotUsingFD(fd)
- FD fd;
+NotUsingFD(
+ FD fd)
{
debug(128,(stderr, "Not Using FD %d\n", fd));
@@ -181,8 +209,8 @@ XtransConnInfo GetXTransConnInfo(FD fd)
/* ************************************************************ */
static void
-EOFonFD(fd)
- FD fd;
+EOFonFD (
+ FD fd)
{
enterprocedure("EOFonFD");
debug(128,(stderr, "EOF on %d\n", fd));
@@ -195,16 +223,189 @@ EOFonFD(fd)
NotUsingFD(fd);
}
+FD
+AcceptConnection (
+ FD ConnectionSocket)
+{
+ FD ClientFD;
+ struct sockaddr_in from;
+ int len = sizeof (from);
+ int tmp = 1;
+
+ enterprocedure("ConnectToClient");
+
+ ClientFD = accept(ConnectionSocket, (struct sockaddr *)&from, &len);
+ debug(4,(stderr, "Connect To Client: FD %d\n", ClientFD));
+ if (ClientFD < 0 && errno == EWOULDBLOCK)
+ {
+ debug(4,(stderr, "Almost blocked accepting FD %d\n", ClientFD));
+ panic("Can't connect to Client");
+ }
+ if (ClientFD < 0)
+ {
+ debug(4,(stderr, "NewConnection: error %d\n", errno));
+ panic("Can't connect to Client");
+ }
+
+#ifdef FD_CLOEXEC
+ (void)fcntl(ClientFD, F_SETFD, FD_CLOEXEC);
+#else
+ (void)ioctl(ClientFD, FIOCLEX, 0);
+#endif
+ /* ultrix reads hang on Unix sockets, hpux reads fail */
+#if defined(O_NONBLOCK) && (!defined(ultrix) && !defined(hpux))
+ (void) fcntl (ClientFD, F_SETFL, O_NONBLOCK);
+#else
+#ifdef FIOSNBIO
+ ioctl (ClientFD, FIOSNBIO, &ON);
+#else
+ (void) fcntl (ClientFD, F_SETFL, FNDELAY);
+#endif
+#endif
+ (void) setsockopt(ClientFD, IPPROTO_TCP, TCP_NODELAY, (char *) &tmp, sizeof (int));
+ return(ClientFD);
+}
+
+FD
+MakeConnection(
+ char *server,
+ short port,
+ int report,
+ XtransConnInfo *trans_conn /* transport connection object */
+ )
+{
+ FD ServerFD;
+#ifdef USE_XTRANS
+ char address[256];
+ int connect_stat;
+
+ snprintf (address, sizeof(address), "%s:%ld", server, port - ServerBasePort);
+ if ( (*trans_conn = _X11TransOpenCOTSClient(address)) == NULL ) {
+ debug(1,(stderr, "OpenCOTSClient failed\n"));
+ panic("Can't open connection to Server");
+ }
+ if ((connect_stat = _X11TransConnect(*trans_conn,address)) < 0 ) {
+ _X11TransClose(*trans_conn);
+ *trans_conn = NULL;
+ debug(1,(stderr, "TransConnect failed\n"));
+ panic("Can't open connection to Server");
+ }
+ ServerFD = _X11TransGetConnectionNumber(*trans_conn);
+#else /* !USE_XTRANS */
+ char HostName[512];
+ struct sockaddr_in sin;
+ struct sockaddr_un sun;
+ struct sockaddr *saddr;
+ int salen;
+ struct hostent *hp;
+ int tmp = 1;
+#ifndef SO_DONTLINGER
+ struct linger linger;
+#endif /* SO_DONTLINGER */
+
+ enterprocedure("ConnectToServer");
+
+ /* establish a socket to the name server for this host */
+ /* determine the host machine for this process */
+ if (*server == '\0')
+ {
+ sun.sun_family = AF_UNIX;
+ sprintf (sun.sun_path, "/tmp/.X11-unix/X%d", port - 6000);
+ salen = sizeof (sun.sun_family) + strlen (sun.sun_path) + 1;
+ saddr = (struct sockaddr *) &sun;
+ }
+ else
+ {
+ debug(4,(stderr, "try to connect on %s\n", server));
+
+ bzero((char *)&sin, sizeof(sin));
+ sin.sin_addr.s_addr = inet_addr (server);
+ if ((long) sin.sin_addr.s_addr == -1)
+ {
+ hp = gethostbyname(server);
+ if (hp == 0)
+ {
+ perror("gethostbyname failed");
+ debug(1,(stderr, "gethostbyname failed for %s\n", server));
+ panic("Can't open connection to Server");
+ }
+ bcopy((char *)hp->h_addr, (char *)&sin.sin_addr, hp->h_length);
+ }
+
+ sin.sin_family = AF_INET;
+
+ if (port == ScopePort
+ && strcmp(server, ScopeHost) == 0)
+ {
+ char error_message[100];
+ (void)sprintf(error_message, "Trying to attach to myself: %s,%d\n",
+ server, sin.sin_port);
+ panic(error_message);
+ }
+
+ sin.sin_port = htons (port);
+ salen = sizeof (sin);
+ saddr = (struct sockaddr *) &sin;
+ }
+
+ ServerFD = socket(saddr->sa_family, SOCK_STREAM, 0);
+ if (ServerFD < 0)
+ {
+ perror("socket() to Server failed");
+ debug(1,(stderr, "socket failed\n"));
+ panic("Can't open connection to Server");
+ }
+ (void) setsockopt(ServerFD, SOL_SOCKET, SO_REUSEADDR, (char *) NULL, 0);
+#ifdef SO_USELOOPBACK
+ (void) setsockopt(ServerFD, SOL_SOCKET, SO_USELOOPBACK,(char *) NULL, 0);
+#endif
+ (void) setsockopt(ServerFD, IPPROTO_TCP, TCP_NODELAY, (char *) &tmp, sizeof (int));
+#ifdef SO_DONTLINGER
+ (void) setsockopt(ServerFD, SOL_SOCKET, SO_DONTLINGER, (char *) NULL, 0);
+#else /* SO_DONTLINGER */
+ linger.l_onoff = 0;
+ linger.l_linger = 0;
+ (void) setsockopt(ServerFD, SOL_SOCKET, SO_LINGER, (char *)&linger, sizeof linger);
+#endif /* SO_DONTLINGER */
+
+ /* ******************************************************** */
+ /* try to connect to Server */
+
+ if (connect(ServerFD, saddr, salen) < 0)
+ {
+ debug(4,(stderr, "connect returns errno of %d\n", errno));
+ if (errno != 0)
+ if (report)
+ perror("connect");
+ switch (errno)
+ {
+ case ECONNREFUSED:
+ /* experience says this is because there is no Server
+ to connect to */
+ (void)close(ServerFD);
+ debug(1,(stderr, "No Server\n"));
+ if (report)
+ warn("Can't open connection to Server");
+ return(-1);
+
+ default:
+ (void)close(ServerFD);
+ panic("Can't open connection to Server");
+ }
+ }
+#endif /* USE_XTRANS */
+
+ debug(4,(stderr, "Connect To Server: FD %d\n", ServerFD));
+ return(ServerFD);
+}
+
/* ************************************************************ */
/* */
/* Main Loop -- wait for input from any source and Process */
/* */
/* ************************************************************ */
-#include <errno.h> /* for EINTR, EADDRINUSE, ... */
-extern int errno;
-
int
MainLoop(void)
{
@@ -212,19 +413,33 @@ MainLoop(void)
while (true)
{
- fd_set rfds, xfds;
+ fd_set rfds, wfds, xfds;
short nfds;
short fd;
/* wait for something */
+
+ /* rfds = ReadDescriptors & ~BlockedReadDescriptors; */
rfds = ReadDescriptors;
+ XFD_UNSET(&rfds, &BlockedReadDescriptors);
+
xfds = rfds;
+ /* wfds = ReadDescriptors & WriteDescriptors; */
+ XFD_ANDSET(&wfds, &ReadDescriptors, &WriteDescriptors);
+
+
debug(128,(stderr, "select %d, rfds = 0%o\n", HighestFD + 1, rfds));
- nfds = select(HighestFD + 1, (struct fd_set *) &rfds,
- (struct fd_set *) NULL, (struct fd_set *) &xfds, NULL);
- debug(128,(stderr, "select nfds = 0%o, rfds = 0%o, xfds 0%o\n",
- nfds, rfds, xfds));
+ if (Interrupt || (!XFD_ANYSET(&rfds) && !XFD_ANYSET(&wfds)))
+ {
+ ReadCommands ();
+ Interrupt = 0;
+ continue;
+ }
+ nfds = select(HighestFD + 1, &rfds, &wfds, &xfds, (struct timeval *)NULL);
+ debug(128,(stderr,
+ "select nfds = 0%o, rfds = 0%o, wfds = 0%o, xfds = 0%o\n",
+ nfds, rfds, wfds, xfds));
if (nfds < 0)
{
@@ -239,7 +454,15 @@ MainLoop(void)
continue;
}
- panic("Select returns error");
+ if (Interrupt)
+ {
+ ReadCommands ();
+ Interrupt = 0;
+ }
+ else
+ {
+ panic("Select returns error");
+ }
continue /* to end of while loop */ ;
}
@@ -250,25 +473,32 @@ MainLoop(void)
}
/* check each fd to see if it has input */
- for (fd = 0; 0 < nfds && fd <= HighestFD; fd++)
+ for (fd = 0; fd <= HighestFD; fd++)
{
/*
check all returned fd's; this prevents
starvation of later clients by earlier clients
*/
- if (FD_ISSET(fd,&rfds) == 0)
- continue;
-
- nfds -= 1;
-
- if (FDD[fd].InputHandler == NULL)
+ if (FD_ISSET(fd,&rfds))
+ {
+ if (FDD[fd].InputHandler == NULL)
+ {
+ panic("FD selected with no handler");
+ debug(1,(stderr, "FD %d has NULL handler\n", fd));
+ }
+ else
+ (FDD[fd].InputHandler)(fd);
+ }
+ if (FD_ISSET(fd,&wfds))
+ {
+ if (FDD[fd].FlushHandler == NULL)
{
- panic("FD selected with no handler");
- debug(1,(stderr, "FD %d has NULL handler\n", fd));
+ panic("FD selected with no flush handler");
}
- else
- (FDD[fd].InputHandler)(fd);
+ else
+ (FDD[fd].FlushHandler)(fd);
+ }
}
}
return 0;
diff --git a/fd.h b/fd.h
index 51caf68..bd4f262 100644
--- a/fd.h
+++ b/fd.h
@@ -53,6 +53,8 @@
*
********************************************** */
+#ifndef XSCOPE_FD_H
+#define XSCOPE_FD_H
/*
the following structure remembers for each file descriptor its
@@ -74,25 +76,39 @@ typedef int FD;
struct FDDescriptor
{
Boolean Busy;
- void (*InputHandler)(int);
+ void (*InputHandler)(int);
+ void (*FlushHandler)(int);
#ifdef USE_XTRANS
XtransConnInfo trans_conn;
#endif
};
-struct FDDescriptor *FDD /* array of FD descriptors */ ;
-int MaxFD /* maximum number of FD's possible */ ;
-int nFDsInUse /* number of FD's actually in use */ ;
-fd_set ReadDescriptors /* bit map of FD's in use -- for select */ ;
-int HighestFD /* highest FD in use -- for select */ ;
+extern struct FDDescriptor *FDD /* array of FD descriptors */ ;
+extern short MaxFD /* maximum number of FD's possible */ ;
+
+extern short nFDsInUse /* number of FD's actually in use */ ;
+
+extern fd_set ReadDescriptors /* bit map of FD's in use -- for select */ ;
+extern fd_set WriteDescriptors /* bit map of write blocked FD's -- for select */;
+extern fd_set BlockedReadDescriptors /* bit map of FD's blocked from reading */;
+extern short HighestFD /* highest FD in use -- for select */ ;
/* need to change the MaxFD to allow larger number of fd's */
#define StaticMaxFD FD_SETSIZE
extern void InitializeFD(void);
-extern void UsingFD(FD fd, void (*Handler)(int), XtransConnInfo trans_conn);
+extern void UsingFD(FD fd, void (*Handler)(int), void (*FlushHandler)(int),
+ XtransConnInfo trans_conn);
extern void NotUsingFD(FD fd);
+
+extern FD AcceptConnection (FD ConnectionSocket);
+extern FD MakeConnection (char *server, short port, int report,
+ XtransConnInfo *trans_conn);
+
extern int MainLoop(void);
+
#ifdef USE_XTRANS
extern XtransConnInfo GetXTransConnInfo(FD fd);
#endif
+
+#endif /* XSCOPE_FD_H */
diff --git a/lbxscope.h b/lbxscope.h
new file mode 100644
index 0000000..cf2d5e2
--- /dev/null
+++ b/lbxscope.h
@@ -0,0 +1,58 @@
+/* $XConsortium: pexscope.h,v 5.1 91/02/16 09:31:57 rws Exp $ */
+
+/***********************************************************
+Copyright 1990, 1991 by Sun Microsystems, Inc. and the X Consortium.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Sun Microsystems,
+the X Consortium, and MIT not be used in advertising or publicity
+pertaining to distribution of the software without specific, written
+prior permission.
+
+SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
+SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef _LBXSCOPE_H_
+#define _LBXSCOPE_H_
+
+#define LBXREQUESTHEADER "LBXREQUEST"
+#define LBXREPLYHEADER "LBXREPLY"
+#define LBXEVENTHEADER "LBXEVENT"
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
+
+extern unsigned char LBXRequest;
+extern unsigned char LBXError;
+extern unsigned char LBXEvent;
+
+extern void LbxQueryVersion (FD fd, const unsigned char *buf);
+extern void LbxQueryVersionReply (FD fd, const unsigned char *buf);
+extern void LbxStartProxy (FD fd, const unsigned char *buf);
+extern void LbxStopProxy (FD fd, const unsigned char *buf);
+extern void LbxNewClient (FD fd, const unsigned char *buf);
+extern void LbxCloseClient (FD fd, const unsigned char *buf);
+extern void LbxSwitch (FD fd, const unsigned char *buf);
+extern void LbxModifySequence (FD fd, const unsigned char *buf);
+extern void LbxSwitchEvent (FD fd, const unsigned char *buf);
+extern void LbxCloseEvent (FD fd, const unsigned char *buf);
+
+#endif
+
diff --git a/nas.h b/nas.h
new file mode 100644
index 0000000..04d169f
--- /dev/null
+++ b/nas.h
@@ -0,0 +1,199 @@
+/* ************************************************************ *
+ * *
+ * Type definitions and Connection State for the NAS protocol *
+ * *
+ * James Peterson, 1988 *
+ * (c) Copyright MCC, 1988 *
+ * *
+ * ************************************************************ */
+
+
+#include "x11.h"
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+/*
+ In general, we are called with a buffer of bytes and are supposed to
+ try to make sense of these bytes according to the NAS protocol. There
+ are two different types of communication: requests from the client to
+ the server and replies/errors/events from the server to the client.
+ We must interpret these two differently.
+
+ Also, we must consider that the bytes on the communication socket may
+ be sent asynchronously in any amount. This means that we must be prepared
+ to read in and save some bytes until we get enough to do something with
+ them. For example, suppose that we get a buffer from a client. We would
+ expect it to be a request. The request may be 24 bytes long. We may find,
+ however, that only 16 bytes have actually arrived -- the other 8 are stuck
+ in a buffer somewhere. We must be prepared to simply hold the 16 bytes we
+ have until more bytes arrive.
+
+ In general, we do two things: we wait for some number of bytes, and
+ then we interpret this set of bytes. To interpret this data we use
+ a modified state machine. We keep two pieces of information:
+
+ (1) the number of bytes that we need
+ (2) what to do with those bytes.
+
+ This last piece of information is the "state" of the interpretation.
+ We keep the state as a pointer to the procedure that is to be executed.
+
+
+ CLIENTS:
+
+ The data going from the client to the x11 server consists of a
+ set-up message followed by an infinite stream of variable length
+ requests.
+
+ Our overall flow is then:
+
+ (a) Wait for 12 bytes.
+ (b) Interpret these first 12 bytes of the set-up message to get the
+ length of the rest of the message.
+ (c) Wait for the rest of the set-up message.
+ (d) Interpret and print the set-up message.
+
+ *** end of set-up phase -- start normal request loop ***
+
+ (e) Wait for 4 bytes.
+ (f) Interpret these 4 bytes to get the length of the rest of the command.
+ (g) Wait for the rest of the command.
+ (h) Interpret and print the command.
+ (i) Go back to step (e).
+
+ SERVERS:
+
+ Again, we have a set-up reply followed by an infinite stream of variable
+ length replies/errors/events.
+
+ Our overall flow is then:
+
+ (a) Wait for 8 bytes.
+ (b) Interpret the 8 bytes to get the length of the rest of the set-up reply.
+ (c) Wait for the rest of the set-up reply.
+ (d) Interpret and print the set-up reply.
+
+ *** end of set-up phase -- start normal reply/error/event loop ***
+
+ We have the following properties of NAS replies, errors, and events:
+
+ Replies: 32 bytes plus a variable amount. Byte 0 is 1.
+ Bytes 2-3 are a sequence number; bytes 4-7 are length (n). The
+ complete length of the reply is 32 + 4 * n.
+
+ Errors: 32 bytes. Byte 0 is 0.
+ Byte 1 is an error code; bytes 2-3 are a sequence number.
+ Bytes 8-9 are a major opcode; byte 10 is a minor opcode.
+
+ Events: 32 bytes. Byte 0 is 2, 3, 4, ....
+
+ Looking at this we have two choices: wait for one byte and then separately
+ wait for replies, errors, and events, or wait for 32 bytes, then separately
+ process each type. We may have to wait for more, in the event of a reply.
+ This latter seems more effective. It appears reply/error/event formats
+ were selected to allow waiting for 32 bytes, and it will allow short packets
+ which are only 32 bytes long, to be processed completely in one step.
+
+ Thus, For normal reply/error/event processing we have
+
+ (e) Wait for 32 bytes.
+ (f) Interpret these 32 bytes. If possible, go back to step (e).
+ (g) If the packet is a reply with bytes 4-7 non-zero, wait for the
+ remainder of the the reply.
+ (h) Interpret and print the longer reply. Go back to step (e).
+
+
+ The similarity in approach to how both the client and server are handled
+ suggests we can use the same control structure to drive the interpretation
+ of both types of communication client->server and server->client.
+ Accordingly, we package up the relevant variables in a ConnState
+ record. The ConnState record contains the buffer of saved bytes (if any),
+ the size and length of this buffer, the number of bytes we are waiting for
+ and what to do when we get them. A separate ConnState record is kept
+ for the client and server.
+
+ In addition, we may have several different client or server connections.
+ Thus we need an array of all the necessary state for each client or server.
+ A client/server is identified with a file descriptor (fd), so we use the
+ fd to identify the client/server and use it as an index into an array of
+ state variables.
+*/
+
+/* audio.c */
+extern void NewAudio (FD fd);
+extern void InitializeAudio (void);
+
+/* decodenas.c */
+extern void DecodeAudioRequest (FD fd, const unsigned char *buf, long n);
+extern void DecodeAudioReply (FD fd, const unsigned char *buf, long n);
+extern void DecodeAudioEvent (FD fd, const unsigned char *buf, long n);
+extern void DecodeAudioError (FD fd, const unsigned char *buf, long n);
+
+extern void InitializeAudioDecode (void);
+
+/* printnas.c */
+extern void PrintAudioSetUpMessage (const unsigned char *buf);
+extern void PrintAudioSetUpReply (const unsigned char *buf);
+extern void AudioElementNotify (const unsigned char *buf);
+extern void AudioGrabNotify (const unsigned char *buf);
+extern void AudioMonitorNotify (const unsigned char *buf);
+extern void AudioBucketNotify (const unsigned char *buf);
+extern void AudioDeviceNotify (const unsigned char *buf);
+extern void UnknownAudioReply (const unsigned char *buf);
+extern void AudioListDevices (const unsigned char *buf);
+extern void AudioListDevicesReply (const unsigned char *buf);
+extern void AudioGetDeviceAttributes (const unsigned char *buf);
+extern void AudioGetDeviceAttributesReply (const unsigned char *buf);
+extern void AudioSetDeviceAttributes (const unsigned char *buf);
+extern void AudioCreateBucket (const unsigned char *buf);
+extern void AudioDestroyBucket (const unsigned char *buf);
+extern void AudioListBuckets (const unsigned char *buf);
+extern void AudioListBucketsReply (const unsigned char *buf);
+extern void AudioGetBucketAttributes (const unsigned char *buf);
+extern void AudioGetBucketAttributesReply (const unsigned char *buf);
+extern void AudioSetBucketAttributes (const unsigned char *buf);
+extern void AudioCreateRadio (const unsigned char *buf);
+extern void AudioDestroyRadio (const unsigned char *buf);
+extern void AudioListRadios (const unsigned char *buf);
+extern void AudioListRadiosReply (const unsigned char *buf);
+extern void AudioGetRadioAttributes (const unsigned char *buf);
+extern void AudioGetRadioAttributesReply (const unsigned char *buf);
+extern void AudioSetRadioAttributes (const unsigned char *buf);
+extern void AudioCreateFlow (const unsigned char *buf);
+extern void AudioDestroyFlow (const unsigned char *buf);
+extern void AudioGetFlowAttributes (const unsigned char *buf);
+extern void AudioGetFlowAttributesReply (const unsigned char *buf);
+extern void AudioSetFlowAttributes (const unsigned char *buf);
+extern void AudioGetElements (const unsigned char *buf);
+extern void AudioGetElementsReply (const unsigned char *buf);
+extern void AudioSetElements (const unsigned char *buf);
+extern void AudioGetElementStates (const unsigned char *buf);
+extern void AudioElementState (const unsigned char *buf);
+extern void AudioGetElementStatesReply (const unsigned char *buf);
+extern void AudioSetElementStates (const unsigned char *buf);
+extern void AudioGetElementParameters (const unsigned char *buf);
+extern void AudioGetElementParametersReply (const unsigned char *buf);
+extern void AudioSetElementParameters (const unsigned char *buf);
+extern void AudioWriteElement (const unsigned char *buf);
+extern void AudioReadElement (const unsigned char *buf);
+extern void AudioReadElementReply (const unsigned char *buf);
+extern void AudioGrabComponent (const unsigned char *buf);
+extern void AudioUngrabComponent (const unsigned char *buf);
+extern void AudioSendEvent (const unsigned char *buf);
+extern void AudioGetAllowedUsers (const unsigned char *buf);
+extern void AudioGetAllowedUsersReply (const unsigned char *buf);
+extern void AudioSetAllowedUsers (const unsigned char *buf);
+extern void AudioListExtensions (const unsigned char *buf);
+extern void AudioListExtensionsReply (const unsigned char *buf);
+extern void AudioQueryExtension (const unsigned char *buf);
+extern void AudioQueryExtensionReply (const unsigned char *buf);
+extern void AudioGetCloseDownMode (const unsigned char *buf);
+extern void AudioGetCloseDownModeReply (const unsigned char *buf);
+extern void AudioSetCloseDownMode (const unsigned char *buf);
+extern void AudioKillClient (const unsigned char *buf);
+extern void AudioGetServerTime (const unsigned char *buf);
+extern void AudioGetServerTimeReply (const unsigned char *buf);
+extern void AudioNoOperation (const unsigned char *buf);
diff --git a/print11.c b/print11.c
index 687bf6c..3d7984a 100644
--- a/print11.c
+++ b/print11.c
@@ -23,7 +23,7 @@
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
* *
- * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
+ * Copyright 2002, 2009 Sun Microsystems, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
@@ -55,10 +55,10 @@
#include "scope.h"
#include "x11.h"
-static void PrintFailedSetUpReply(unsigned char *buf);
-static void PrintSuccessfulSetUpReply(unsigned char *buf);
-static void ListFontsWithInfoReply1(unsigned char *buf);
-static void ListFontsWithInfoReply2(unsigned char *buf);
+static void PrintFailedSetUpReply(const unsigned char *buf);
+static void PrintSuccessfulSetUpReply(const unsigned char *buf);
+static void ListFontsWithInfoReply1(const unsigned char *buf);
+static void ListFontsWithInfoReply2(const unsigned char *buf);
/* ************************************************************ */
@@ -90,15 +90,14 @@ static void ListFontsWithInfoReply2(unsigned char *buf);
#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
-
/* ************************************************************ */
/* */
/* */
/* ************************************************************ */
void
-PrintSetUpMessage(buf)
- unsigned char *buf;
+PrintSetUpMessage (
+ const unsigned char *buf)
{
short n;
short d;
@@ -119,8 +118,8 @@ PrintSetUpMessage(buf)
}
void
-PrintSetUpReply(buf)
- unsigned char *buf;
+PrintSetUpReply (
+ const unsigned char *buf)
{
enterprocedure("PrintSetUpReply");
SetIndentLevel(PRINTSERVER);
@@ -131,8 +130,8 @@ PrintSetUpReply(buf)
}
static void
-PrintFailedSetUpReply(buf)
- unsigned char *buf;
+PrintFailedSetUpReply (
+ const unsigned char *buf)
{
short n;
@@ -148,8 +147,8 @@ PrintFailedSetUpReply(buf)
}
static void
-PrintSuccessfulSetUpReply(buf)
- unsigned char *buf;
+PrintSuccessfulSetUpReply (
+ const unsigned char *buf)
{
short v;
short n;
@@ -187,10 +186,10 @@ PrintSuccessfulSetUpReply(buf)
/* */
/* ************************************************************ */
-static char *REQUESTHEADER = "............REQUEST";
-static char *EVENTHEADER = "..............EVENT";
-static char *ERRORHEADER = "..............ERROR";
-static char *REPLYHEADER = "..............REPLY";
+const char REQUESTHEADER[] = "............REQUEST";
+const char EVENTHEADER[] = "..............EVENT";
+const char ERRORHEADER[] = "..............ERROR";
+const char REPLYHEADER[] = "..............REPLY";
/* ************************************************************ */
@@ -201,8 +200,8 @@ static char *REPLYHEADER = "..............REPLY";
/* Error Printing procedures */
void
-RequestError(buf)
- unsigned char *buf;
+RequestError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
if (Verbose < 1)
@@ -213,8 +212,8 @@ RequestError(buf)
}
void
-ValueError(buf)
- unsigned char *buf;
+ValueError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Value */ ;
if (Verbose < 1)
@@ -226,8 +225,8 @@ ValueError(buf)
}
void
-WindowError(buf)
- unsigned char *buf;
+WindowError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Window */ ;
if (Verbose < 1)
@@ -239,8 +238,8 @@ WindowError(buf)
}
void
-PixmapError(buf)
- unsigned char *buf;
+PixmapError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Pixmap */ ;
if (Verbose < 1)
@@ -252,8 +251,8 @@ PixmapError(buf)
}
void
-AtomError(buf)
- unsigned char *buf;
+AtomError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Atom */ ;
if (Verbose < 1)
@@ -265,8 +264,8 @@ AtomError(buf)
}
void
-CursorError(buf)
- unsigned char *buf;
+CursorError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Cursor */ ;
if (Verbose < 1)
@@ -278,8 +277,8 @@ CursorError(buf)
}
void
-FontError(buf)
- unsigned char *buf;
+FontError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Font */ ;
if (Verbose < 1)
@@ -291,8 +290,8 @@ FontError(buf)
}
void
-MatchError(buf)
- unsigned char *buf;
+MatchError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Match */ ;
if (Verbose < 1)
@@ -303,8 +302,8 @@ MatchError(buf)
}
void
-DrawableError(buf)
- unsigned char *buf;
+DrawableError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Drawable */ ;
if (Verbose < 1)
@@ -316,8 +315,8 @@ DrawableError(buf)
}
void
-AccessError(buf)
- unsigned char *buf;
+AccessError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Access */ ;
if (Verbose < 1)
@@ -328,8 +327,8 @@ AccessError(buf)
}
void
-AllocError(buf)
- unsigned char *buf;
+AllocError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Alloc */ ;
if (Verbose < 1)
@@ -340,8 +339,8 @@ AllocError(buf)
}
void
-ColormapError(buf)
- unsigned char *buf;
+ColormapError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Colormap */ ;
if (Verbose < 1)
@@ -353,8 +352,8 @@ ColormapError(buf)
}
void
-GContextError(buf)
- unsigned char *buf;
+GContextError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* GContext */ ;
if (Verbose < 1)
@@ -366,8 +365,8 @@ GContextError(buf)
}
void
-IDChoiceError(buf)
- unsigned char *buf;
+IDChoiceError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* IDChoice */ ;
if (Verbose < 1)
@@ -379,8 +378,8 @@ IDChoiceError(buf)
}
void
-NameError(buf)
- unsigned char *buf;
+NameError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Name */ ;
if (Verbose < 1)
@@ -391,8 +390,8 @@ NameError(buf)
}
void
-LengthError(buf)
- unsigned char *buf;
+LengthError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Length */ ;
if (Verbose < 1)
@@ -403,8 +402,8 @@ LengthError(buf)
}
void
-ImplementationError(buf)
- unsigned char *buf;
+ImplementationError (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Implementation */ ;
if (Verbose < 1)
@@ -422,8 +421,8 @@ ImplementationError(buf)
/* Event Printing procedures */
void
-KeyPressEvent(buf)
- unsigned char *buf;
+KeyPressEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* KeyPress */ ;
if (Verbose < 1)
@@ -443,8 +442,8 @@ KeyPressEvent(buf)
}
void
-KeyReleaseEvent(buf)
- unsigned char *buf;
+KeyReleaseEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* KeyRelease */ ;
if (Verbose < 1)
@@ -464,8 +463,8 @@ KeyReleaseEvent(buf)
}
void
-ButtonPressEvent(buf)
- unsigned char *buf;
+ButtonPressEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ButtonPress */ ;
if (Verbose < 1)
@@ -485,8 +484,8 @@ ButtonPressEvent(buf)
}
void
-ButtonReleaseEvent(buf)
- unsigned char *buf;
+ButtonReleaseEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ButtonRelease */ ;
if (Verbose < 1)
@@ -506,8 +505,8 @@ ButtonReleaseEvent(buf)
}
void
-MotionNotifyEvent(buf)
- unsigned char *buf;
+MotionNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* MotionNotify */ ;
if (Verbose < 1)
@@ -527,8 +526,8 @@ MotionNotifyEvent(buf)
}
void
-EnterNotifyEvent(buf)
- unsigned char *buf;
+EnterNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* EnterNotify */ ;
if (Verbose < 1)
@@ -549,8 +548,8 @@ EnterNotifyEvent(buf)
}
void
-LeaveNotifyEvent(buf)
- unsigned char *buf;
+LeaveNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* LeaveNotify */ ;
if (Verbose < 1)
@@ -571,8 +570,8 @@ LeaveNotifyEvent(buf)
}
void
-FocusInEvent(buf)
- unsigned char *buf;
+FocusInEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* FocusIn */ ;
if (Verbose < 1)
@@ -584,8 +583,8 @@ FocusInEvent(buf)
}
void
-FocusOutEvent(buf)
- unsigned char *buf;
+FocusOutEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* FocusOut */ ;
if (Verbose < 1)
@@ -597,8 +596,8 @@ FocusOutEvent(buf)
}
void
-KeymapNotifyEvent(buf)
- unsigned char *buf;
+KeymapNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* KeymapNotify */ ;
if (Verbose < 1)
@@ -607,8 +606,8 @@ KeymapNotifyEvent(buf)
}
void
-ExposeEvent(buf)
- unsigned char *buf;
+ExposeEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* Expose */ ;
if (Verbose < 1)
@@ -623,8 +622,8 @@ ExposeEvent(buf)
}
void
-GraphicsExposureEvent(buf)
- unsigned char *buf;
+GraphicsExposureEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* GraphicsExposure */ ;
if (Verbose < 1)
@@ -641,8 +640,8 @@ GraphicsExposureEvent(buf)
}
void
-NoExposureEvent(buf)
- unsigned char *buf;
+NoExposureEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* NoExposure */ ;
if (Verbose < 1)
@@ -654,8 +653,8 @@ NoExposureEvent(buf)
}
void
-VisibilityNotifyEvent(buf)
- unsigned char *buf;
+VisibilityNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* VisibilityNotify */ ;
if (Verbose < 1)
@@ -666,8 +665,8 @@ VisibilityNotifyEvent(buf)
}
void
-CreateNotifyEvent(buf)
- unsigned char *buf;
+CreateNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* CreateNotify */ ;
if (Verbose < 1)
@@ -684,8 +683,8 @@ CreateNotifyEvent(buf)
}
void
-DestroyNotifyEvent(buf)
- unsigned char *buf;
+DestroyNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* DestroyNotify */ ;
if (Verbose < 1)
@@ -696,8 +695,8 @@ DestroyNotifyEvent(buf)
}
void
-UnmapNotifyEvent(buf)
- unsigned char *buf;
+UnmapNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* UnmapNotify */ ;
if (Verbose < 1)
@@ -709,8 +708,8 @@ UnmapNotifyEvent(buf)
}
void
-MapNotifyEvent(buf)
- unsigned char *buf;
+MapNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* MapNotify */ ;
if (Verbose < 1)
@@ -722,8 +721,8 @@ MapNotifyEvent(buf)
}
void
-MapRequestEvent(buf)
- unsigned char *buf;
+MapRequestEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* MapRequest */ ;
if (Verbose < 1)
@@ -734,8 +733,8 @@ MapRequestEvent(buf)
}
void
-ReparentNotifyEvent(buf)
- unsigned char *buf;
+ReparentNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ReparentNotify */ ;
if (Verbose < 1)
@@ -750,8 +749,8 @@ ReparentNotifyEvent(buf)
}
void
-ConfigureNotifyEvent(buf)
- unsigned char *buf;
+ConfigureNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ConfigureNotify */ ;
if (Verbose < 1)
@@ -769,8 +768,8 @@ ConfigureNotifyEvent(buf)
}
void
-ConfigureRequestEvent(buf)
- unsigned char *buf;
+ConfigureRequestEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ConfigureRequest */ ;
if (Verbose < 1)
@@ -789,8 +788,8 @@ ConfigureRequestEvent(buf)
}
void
-GravityNotifyEvent(buf)
- unsigned char *buf;
+GravityNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* GravityNotify */ ;
if (Verbose < 1)
@@ -803,8 +802,8 @@ GravityNotifyEvent(buf)
}
void
-ResizeRequestEvent(buf)
- unsigned char *buf;
+ResizeRequestEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ResizeRequest */ ;
if (Verbose < 1)
@@ -816,8 +815,8 @@ ResizeRequestEvent(buf)
}
void
-CirculateNotifyEvent(buf)
- unsigned char *buf;
+CirculateNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* CirculateNotify */ ;
if (Verbose < 1)
@@ -830,8 +829,8 @@ CirculateNotifyEvent(buf)
}
void
-CirculateRequestEvent(buf)
- unsigned char *buf;
+CirculateRequestEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* CirculateRequest */ ;
if (Verbose < 1)
@@ -843,8 +842,8 @@ CirculateRequestEvent(buf)
}
void
-PropertyNotifyEvent(buf)
- unsigned char *buf;
+PropertyNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* PropertyNotify */ ;
if (Verbose < 1)
@@ -857,8 +856,8 @@ PropertyNotifyEvent(buf)
}
void
-SelectionClearEvent(buf)
- unsigned char *buf;
+SelectionClearEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* SelectionClear */ ;
if (Verbose < 1)
@@ -870,8 +869,8 @@ SelectionClearEvent(buf)
}
void
-SelectionRequestEvent(buf)
- unsigned char *buf;
+SelectionRequestEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* SelectionRequest */ ;
if (Verbose < 1)
@@ -886,8 +885,8 @@ SelectionRequestEvent(buf)
}
void
-SelectionNotifyEvent(buf)
- unsigned char *buf;
+SelectionNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* SelectionNotify */ ;
if (Verbose < 1)
@@ -901,8 +900,8 @@ SelectionNotifyEvent(buf)
}
void
-ColormapNotifyEvent(buf)
- unsigned char *buf;
+ColormapNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ColormapNotify */ ;
if (Verbose < 1)
@@ -915,8 +914,8 @@ ColormapNotifyEvent(buf)
}
void
-ClientMessageEvent(buf)
- unsigned char *buf;
+ClientMessageEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* ClientMessage */ ;
if (Verbose < 1)
@@ -929,8 +928,8 @@ ClientMessageEvent(buf)
}
void
-MappingNotifyEvent(buf)
- unsigned char *buf;
+MappingNotifyEvent (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* MappingNotify */ ;
if (Verbose < 1)
@@ -949,18 +948,51 @@ MappingNotifyEvent(buf)
/* Request and Reply Printing procedures */
void
-CreateWindow(buf)
- unsigned char *buf;
+ExtendedRequest (
+ int fd,
+ const unsigned char *buf)
+{
+ short n;
+ PrintField(buf, 0, 1, REQUEST, REQUESTHEADER);
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ PrintField(buf, 1, 1, CARD8, "minor opcode");
+ printreqlen(buf, fd, DVALUE2(n-1));
+
+ n = CS[fd].requestLen - 1;
+ (void) PrintList (&buf[4], n, CARD32, "data");
+}
+
+void
+UnknownReply (
+ const unsigned char *buf)
+{
+ long n;
+
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER);
+ PrintField(buf, 1, 1, CARD8, "data");
+ printfield (buf, 2, 2, CARD16, "sequence number");
+ printfield (buf, 4, 4, DVALUE4(n), "reply length");
+ n = ILong (&buf[4]) + 6;
+ (void) PrintList (&buf[8], n, CARD32, "data");
+}
+
+void
+CreateWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CreateWindow is opcode 1 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CreateWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, CARD8, "depth");
- printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(8 + n));
PrintField(buf, 4, 4, WINDOW, "wid");
PrintField(buf, 8, 4, WINDOW, "parent");
PrintField(buf, 12, 2, INT16, "x");
@@ -975,40 +1007,42 @@ CreateWindow(buf)
}
void
-ChangeWindowAttributes(buf)
- unsigned char *buf;
+ChangeWindowAttributes (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ChangeWindowAttributes is opcode 2 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ChangeWindowAttributes */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 4, WINDOW_BITMASK, "value-mask");
PrintValues(&buf[8], 4, WINDOW_BITMASK, &buf[12], "value-list");
}
void
-GetWindowAttributes(buf)
- unsigned char *buf;
+GetWindowAttributes (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetWindowAttributes is opcode 3 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetWindowAttributes */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-GetWindowAttributesReply(buf)
- unsigned char *buf;
+GetWindowAttributesReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetWindowAttributes */ ;
if (Verbose < 1)
@@ -1033,63 +1067,67 @@ GetWindowAttributesReply(buf)
}
void
-DestroyWindow(buf)
- unsigned char *buf;
+DestroyWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request DestroyWindow is opcode 4 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* DestroyWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-DestroySubwindows(buf)
- unsigned char *buf;
+DestroySubwindows (
+ FD fd,
+ const unsigned char *buf)
{
/* Request DestroySubwindows is opcode 5 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* DestroySubwindows */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-ChangeSaveSet(buf)
- unsigned char *buf;
+ChangeSaveSet (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ChangeSaveSet is opcode 6 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ChangeSaveSet */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, INS_DEL, "mode");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-ReparentWindow(buf)
- unsigned char *buf;
+ReparentWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ReparentWindow is opcode 7 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ReparentWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 4, WINDOW, "parent");
PrintField(buf, 12, 2, INT16, "x");
@@ -1097,116 +1135,123 @@ ReparentWindow(buf)
}
void
-MapWindow(buf)
- unsigned char *buf;
+MapWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request MapWindow is opcode 8 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* MapWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-MapSubwindows(buf)
- unsigned char *buf;
+MapSubwindows (
+ FD fd,
+ const unsigned char *buf)
{
/* Request MapSubwindows is opcode 9 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* MapSubwindows */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-UnmapWindow(buf)
- unsigned char *buf;
+UnmapWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UnmapWindow is opcode 10 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UnmapWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-UnmapSubwindows(buf)
- unsigned char *buf;
+UnmapSubwindows (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UnmapSubwindows is opcode 11 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UnmapSubwindows */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-ConfigureWindow(buf)
- unsigned char *buf;
+ConfigureWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ConfigureWindow is opcode 12 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ConfigureWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 2, CONFIGURE_BITMASK, "value-mask");
PrintValues(&buf[8], 2, CONFIGURE_BITMASK, &buf[12], "value-list");
}
void
-CirculateWindow(buf)
- unsigned char *buf;
+CirculateWindow (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CirculateWindow is opcode 13 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CirculateWindow */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, CIRMODE, "direction");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-GetGeometry(buf)
- unsigned char *buf;
+GetGeometry (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetGeometry is opcode 14 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetGeometry */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, DRAWABLE, "drawable");
}
void
-GetGeometryReply(buf)
- unsigned char *buf;
+GetGeometryReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetGeometry */ ;
if (Verbose < 1)
@@ -1223,23 +1268,24 @@ GetGeometryReply(buf)
}
void
-QueryTree(buf)
- unsigned char *buf;
+QueryTree (
+ FD fd,
+ const unsigned char *buf)
{
/* Request QueryTree is opcode 15 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* QueryTree */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-QueryTreeReply(buf)
- unsigned char *buf;
+QueryTreeReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryTree */ ;
@@ -1255,8 +1301,9 @@ QueryTreeReply(buf)
}
void
-InternAtom(buf)
- unsigned char *buf;
+InternAtom (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request InternAtom is opcode 16 */
@@ -1264,18 +1311,18 @@ InternAtom(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "only-if-exists");
- printfield(buf, 2, 2, DVALUE2(2 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (n + p) / 4));
printfield(buf, 4, 2, DVALUE2(n), "length of name");
n = IShort(&buf[4]);
PrintString8(&buf[8], n, "name");
}
void
-InternAtomReply(buf)
- unsigned char *buf;
+InternAtomReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* InternAtom */ ;
if (Verbose < 1)
@@ -1286,23 +1333,24 @@ InternAtomReply(buf)
}
void
-GetAtomName(buf)
- unsigned char *buf;
+GetAtomName (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetAtomName is opcode 17 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetAtomName */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, ATOM, "atom");
}
void
-GetAtomNameReply(buf)
- unsigned char *buf;
+GetAtomNameReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetAtomName */ ;
@@ -1316,8 +1364,9 @@ GetAtomNameReply(buf)
}
void
-ChangeProperty(buf)
- unsigned char *buf;
+ChangeProperty (
+ FD fd,
+ const unsigned char *buf)
{
long n;
short unit;
@@ -1328,10 +1377,10 @@ ChangeProperty(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, CHANGEMODE, "mode");
- printfield(buf, 2, 2, DVALUE2(6 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(6 + (n + p) / 4));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 4, ATOM, "property");
PrintField(buf, 12, 4, ATOM, "type");
@@ -1347,34 +1396,36 @@ ChangeProperty(buf)
}
void
-DeleteProperty(buf)
- unsigned char *buf;
+DeleteProperty (
+ FD fd,
+ const unsigned char *buf)
{
/* Request DeleteProperty is opcode 19 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* DeleteProperty */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 4, ATOM, "property");
}
void
-GetProperty(buf)
- unsigned char *buf;
+GetProperty (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetProperty is opcode 20 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetProperty */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "delete");
- printfield(buf, 2, 2, CONST2(6), "request length");
+ printreqlen(buf, fd, CONST2(6));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 4, ATOM, "property");
PrintField(buf, 12, 4, ATOMT, "type");
@@ -1383,8 +1434,8 @@ GetProperty(buf)
}
void
-GetPropertyReply(buf)
- unsigned char *buf;
+GetPropertyReply (
+ const unsigned char *buf)
{
long n;
short unit;
@@ -1409,23 +1460,24 @@ GetPropertyReply(buf)
}
void
-ListProperties(buf)
- unsigned char *buf;
+ListProperties (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ListProperties is opcode 21 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ListProperties */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-ListPropertiesReply(buf)
- unsigned char *buf;
+ListPropertiesReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* ListProperties */ ;
@@ -1439,40 +1491,42 @@ ListPropertiesReply(buf)
}
void
-SetSelectionOwner(buf)
- unsigned char *buf;
+SetSelectionOwner (
+ FD fd,
+ const unsigned char *buf)
{
/* Request SetSelectionOwner is opcode 22 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* SetSelectionOwner */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "owner");
PrintField(buf, 8, 4, ATOM, "selection");
PrintField(buf, 12, 4, TIMESTAMP, "time");
}
void
-GetSelectionOwner(buf)
- unsigned char *buf;
+GetSelectionOwner (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetSelectionOwner is opcode 23 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetSelectionOwner */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, ATOM, "selection");
}
void
-GetSelectionOwnerReply(buf)
- unsigned char *buf;
+GetSelectionOwnerReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetSelectionOwner */ ;
if (Verbose < 1)
@@ -1483,17 +1537,18 @@ GetSelectionOwnerReply(buf)
}
void
-ConvertSelection(buf)
- unsigned char *buf;
+ConvertSelection (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ConvertSelection is opcode 24 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ConvertSelection */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(6), "request length");
+ printreqlen(buf, fd, CONST2(6));
PrintField(buf, 4, 4, WINDOW, "requestor");
PrintField(buf, 8, 4, ATOM, "selection");
PrintField(buf, 12, 4, ATOM, "target");
@@ -1502,36 +1557,38 @@ ConvertSelection(buf)
}
void
-SendEvent(buf)
- unsigned char *buf;
+SendEvent (
+ FD fd,
+ const unsigned char *buf)
{
/* Request SendEvent is opcode 25 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* SendEvent */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "propagate");
- printfield(buf, 2, 2, CONST2(11), "request length");
+ printreqlen(buf, fd, CONST2(11));
PrintField(buf, 4, 4, WINDOWD, "destination");
PrintField(buf, 8, 4, SETofEVENT, "event-mask");
PrintField(buf, 12, 32, EVENTFORM, "event");
}
void
-GrabPointer(buf)
- unsigned char *buf;
+GrabPointer (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GrabPointer is opcode 26 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GrabPointer */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "owner-events");
- printfield(buf, 2, 2, CONST2(6), "request length");
+ printreqlen(buf, fd, CONST2(6));
PrintField(buf, 4, 4, WINDOW, "grab-window");
PrintField(buf, 8, 2, SETofPOINTEREVENT, "event-mask");
PrintField(buf, 10, 1, PK_MODE, "pointer-mode");
@@ -1542,8 +1599,8 @@ GrabPointer(buf)
}
void
-GrabPointerReply(buf)
- unsigned char *buf;
+GrabPointerReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GrabPointer */ ;
if (Verbose < 1)
@@ -1554,33 +1611,35 @@ GrabPointerReply(buf)
}
void
-UngrabPointer(buf)
- unsigned char *buf;
+UngrabPointer (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UngrabPointer is opcode 27 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UngrabPointer */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, TIMESTAMP, "time");
}
void
-GrabButton(buf)
- unsigned char *buf;
+GrabButton (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GrabButton is opcode 28 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GrabButton */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "owner-events");
- printfield(buf, 2, 2, CONST2(6), "request length");
+ printreqlen(buf, fd, CONST2(6));
PrintField(buf, 4, 4, WINDOW, "grab-window");
PrintField(buf, 8, 2, SETofPOINTEREVENT, "event-mask");
PrintField(buf, 10, 1, PK_MODE, "pointer-mode");
@@ -1592,52 +1651,55 @@ GrabButton(buf)
}
void
-UngrabButton(buf)
- unsigned char *buf;
+UngrabButton (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UngrabButton is opcode 29 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UngrabButton */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BUTTONA, "button");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, WINDOW, "grab-window");
PrintField(buf, 8, 2, SETofKEYMASK, "modifiers");
}
void
-ChangeActivePointerGrab(buf)
- unsigned char *buf;
+ChangeActivePointerGrab (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ChangeActivePointerGrab is opcode 30 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ChangeActivePointerGrab */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, CURSOR, "cursor");
PrintField(buf, 8, 4, TIMESTAMP, "time");
PrintField(buf, 12, 2, SETofPOINTEREVENT, "event-mask");
}
void
-GrabKeyboard(buf)
- unsigned char *buf;
+GrabKeyboard (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GrabKeyboard is opcode 31 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GrabKeyboard */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "owner-events");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "grab-window");
PrintField(buf, 8, 4, TIMESTAMP, "time");
PrintField(buf, 12, 1, PK_MODE, "pointer-mode");
@@ -1645,8 +1707,8 @@ GrabKeyboard(buf)
}
void
-GrabKeyboardReply(buf)
- unsigned char *buf;
+GrabKeyboardReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GrabKeyboard */ ;
if (Verbose < 1)
@@ -1657,33 +1719,35 @@ GrabKeyboardReply(buf)
}
void
-UngrabKeyboard(buf)
- unsigned char *buf;
+UngrabKeyboard (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UngrabKeyboard is opcode 32 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UngrabKeyboard */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, TIMESTAMP, "time");
}
void
-GrabKey(buf)
- unsigned char *buf;
+GrabKey (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GrabKey is opcode 33 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GrabKey */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "owner-events");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "grab-window");
PrintField(buf, 8, 2, SETofKEYMASK, "modifiers");
PrintField(buf, 10, 1, KEYCODEA, "key");
@@ -1692,84 +1756,89 @@ GrabKey(buf)
}
void
-UngrabKey(buf)
- unsigned char *buf;
+UngrabKey (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UngrabKey is opcode 34 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UngrabKey */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, KEYCODEA, "key");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, WINDOW, "grab-window");
PrintField(buf, 8, 2, SETofKEYMASK, "modifiers");
}
void
-AllowEvents(buf)
- unsigned char *buf;
+AllowEvents (
+ FD fd,
+ const unsigned char *buf)
{
/* Request AllowEvents is opcode 35 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* AllowEvents */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, EVENTMODE, "mode");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, TIMESTAMP, "time");
}
void
-GrabServer(buf)
- unsigned char *buf;
+GrabServer (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GrabServer is opcode 36 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GrabServer */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-UngrabServer(buf)
- unsigned char *buf;
+UngrabServer (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UngrabServer is opcode 37 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UngrabServer */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-QueryPointer(buf)
- unsigned char *buf;
+QueryPointer (
+ FD fd,
+ const unsigned char *buf)
{
/* Request QueryPointer is opcode 38 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* QueryPointer */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-QueryPointerReply(buf)
- unsigned char *buf;
+QueryPointerReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryPointer */ ;
if (Verbose < 1)
@@ -1787,25 +1856,26 @@ QueryPointerReply(buf)
}
void
-GetMotionEvents(buf)
- unsigned char *buf;
+GetMotionEvents (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetMotionEvents is opcode 39 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetMotionEvents */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 4, TIMESTAMP, "start");
PrintField(buf, 12, 4, TIMESTAMP, "stop");
}
void
-GetMotionEventsReply(buf)
- unsigned char *buf;
+GetMotionEventsReply (
+ const unsigned char *buf)
{
long n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetMotionEvents */ ;
@@ -1819,17 +1889,18 @@ GetMotionEventsReply(buf)
}
void
-TranslateCoordinates(buf)
- unsigned char *buf;
+TranslateCoordinates (
+ FD fd,
+ const unsigned char *buf)
{
/* Request TranslateCoordinates is opcode 40 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* TranslateCoordinates */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "src-window");
PrintField(buf, 8, 4, WINDOW, "dst-window");
PrintField(buf, 12, 2, INT16, "src-x");
@@ -1837,8 +1908,8 @@ TranslateCoordinates(buf)
}
void
-TranslateCoordinatesReply(buf)
- unsigned char *buf;
+TranslateCoordinatesReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* TranslateCoordinates */ ;
if (Verbose < 1)
@@ -1852,17 +1923,18 @@ TranslateCoordinatesReply(buf)
}
void
-WarpPointer(buf)
- unsigned char *buf;
+WarpPointer (
+ FD fd,
+ const unsigned char *buf)
{
/* Request WarpPointer is opcode 41 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* WarpPointer */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(6), "request length");
+ printreqlen(buf, fd, CONST2(6));
PrintField(buf, 4, 4, WINDOW, "src-window");
PrintField(buf, 8, 4, WINDOW, "dst-window");
PrintField(buf, 12, 2, INT16, "src-x");
@@ -1874,39 +1946,41 @@ WarpPointer(buf)
}
void
-SetInputFocus(buf)
- unsigned char *buf;
+SetInputFocus (
+ FD fd,
+ const unsigned char *buf)
{
/* Request SetInputFocus is opcode 42 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* SetInputFocus */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, FOCUSAGENT, "revert-to");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, WINDOWNR, "focus");
PrintField(buf, 8, 4, TIMESTAMP, "time");
}
void
-GetInputFocus(buf)
- unsigned char *buf;
+GetInputFocus (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetInputFocus is opcode 43 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetInputFocus */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-GetInputFocusReply(buf)
- unsigned char *buf;
+GetInputFocusReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetInputFocus */ ;
if (Verbose < 1)
@@ -1918,22 +1992,23 @@ GetInputFocusReply(buf)
}
void
-QueryKeymap(buf)
- unsigned char *buf;
+QueryKeymap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request QueryKeymap is opcode 44 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* QueryKeymap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-QueryKeymapReply(buf)
- unsigned char *buf;
+QueryKeymapReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryKeymap */ ;
if (Verbose < 1)
@@ -1944,8 +2019,9 @@ QueryKeymapReply(buf)
}
void
-OpenFont(buf)
- unsigned char *buf;
+OpenFont (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request OpenFont is opcode 45 */
@@ -1953,9 +2029,9 @@ OpenFont(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + (n + p) / 4));
PrintField(buf, 4, 4, FONT, "font-id");
printfield(buf, 8, 2, DVALUE2(n), "length of name");
n = IShort(&buf[8]);
@@ -1963,38 +2039,40 @@ OpenFont(buf)
}
void
-CloseFont(buf)
- unsigned char *buf;
+CloseFont (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CloseFont is opcode 46 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CloseFont */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, FONT, "font");
}
void
-QueryFont(buf)
- unsigned char *buf;
+QueryFont (
+ FD fd,
+ const unsigned char *buf)
{
/* Request QueryFont is opcode 47 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* QueryFont */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, FONTABLE, "font");
}
void
-QueryFontReply(buf)
- unsigned char *buf;
+QueryFontReply (
+ const unsigned char *buf)
{
short n;
long m;
@@ -2025,20 +2103,21 @@ QueryFontReply(buf)
}
void
-QueryTextExtents(buf)
- unsigned char *buf;
+QueryTextExtents (
+ FD fd,
+ const unsigned char *buf)
{
- short n;
+ int n;
/* Request QueryTextExtents is opcode 48 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* QueryTextExtents */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
printfield(buf, 1, 1, BOOL, "odd length?");
- printfield(buf, 2, 2, DVALUE2(2 + (2*n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (2*n + p) / 4));
n = (IShort(&buf[2]) - 2) * 4 / 2;
if (IBool(&buf[1]))
n -= 1;
@@ -2047,8 +2126,8 @@ QueryTextExtents(buf)
}
void
-QueryTextExtentsReply(buf)
- unsigned char *buf;
+QueryTextExtentsReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryTextExtents */ ;
if (Verbose < 1)
@@ -2066,8 +2145,9 @@ QueryTextExtentsReply(buf)
}
void
-ListFonts(buf)
- unsigned char *buf;
+ListFonts (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request ListFonts is opcode 49 */
@@ -2075,9 +2155,9 @@ ListFonts(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (n + p) / 4));
PrintField(buf, 4, 2, CARD16, "max-names");
printfield(buf, 6, 2, DVALUE2(n), "length of pattern");
n = IShort(&buf[6]);
@@ -2085,8 +2165,8 @@ ListFonts(buf)
}
void
-ListFontsReply(buf)
- unsigned char *buf;
+ListFontsReply (
+ const unsigned char *buf)
{
short n;
@@ -2101,8 +2181,9 @@ ListFontsReply(buf)
}
void
-ListFontsWithInfo(buf)
- unsigned char *buf;
+ListFontsWithInfo (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request ListFontsWithInfo is opcode 50 */
@@ -2110,9 +2191,9 @@ ListFontsWithInfo(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (n + p) / 4));
PrintField(buf, 4, 2, CARD16, "max-names");
printfield(buf, 6, 2, DVALUE2(n), "length of pattern");
n = IShort(&buf[6]);
@@ -2120,8 +2201,8 @@ ListFontsWithInfo(buf)
}
void
-ListFontsWithInfoReply(buf)
- unsigned char *buf;
+ListFontsWithInfoReply (
+ const unsigned char *buf)
{
short which;
@@ -2139,8 +2220,8 @@ ListFontsWithInfoReply(buf)
}
static void
-ListFontsWithInfoReply1(buf)
- unsigned char *buf;
+ListFontsWithInfoReply1 (
+ const unsigned char *buf)
{
short n;
short m;
@@ -2167,8 +2248,8 @@ ListFontsWithInfoReply1(buf)
}
static void
-ListFontsWithInfoReply2(buf)
- unsigned char *buf;
+ListFontsWithInfoReply2 (
+ const unsigned char *buf)
{
PrintField(buf, 1, 1, CONST1(0), "last-reply indicator");
printfield(buf, 2, 2, CARD16, "sequence number");
@@ -2176,8 +2257,9 @@ ListFontsWithInfoReply2(buf)
}
void
-SetFontPath(buf)
- unsigned char *buf;
+SetFontPath (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request SetFontPath is opcode 51 */
@@ -2185,31 +2267,32 @@ SetFontPath(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (n + p) / 4));
printfield(buf, 4, 2, CARD16, "number of paths");
n = IShort(&buf[4]);
PrintListSTR(&buf[8], (long)n, "paths");
}
void
-GetFontPath(buf)
- unsigned char *buf;
+GetFontPath (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetFontPath is opcode 52 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetFontPath */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 2, 2, CONST2(1), "request list");
}
void
-GetFontPathReply(buf)
- unsigned char *buf;
+GetFontPathReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetFontPath */ ;
@@ -2223,18 +2306,19 @@ GetFontPathReply(buf)
}
void
-CreatePixmap(buf)
- unsigned char *buf;
+CreatePixmap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CreatePixmap is opcode 53 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CreatePixmap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, CARD8, "depth");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, PIXMAP, "pixmap-id");
PrintField(buf, 8, 4, DRAWABLE, "drawable");
PrintField(buf, 12, 2, CARD16, "width");
@@ -2242,32 +2326,63 @@ CreatePixmap(buf)
}
void
-FreePixmap(buf)
- unsigned char *buf;
+FreePixmap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request FreePixmap is opcode 54 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* FreePixmap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, PIXMAP, "pixmap");
}
-void
-CreateGC(buf)
- unsigned char *buf;
-{
+static const unsigned long GCDefaults[] = {
+ 3, /* function GXcopy */
+ ~0, /* planemask */
+ 0, /* foreground */
+ 1, /* background */
+ 0, /* line width */
+ 0, /* line style Solid */
+ 1, /* cap style Butt */
+ 0, /* join style Miter */
+ 0, /* fill style Solid */
+ 0, /* fill rule EvenOdd */
+ 0, /* tile */
+ 0, /* stipple */
+ 0, /* ts org x */
+ 0, /* ts org y */
+ 0, /* font */
+ 0, /* sub window mode ClipByChildren */
+ 1, /* graphics expose True */
+ 0, /* clip x org */
+ 0, /* clip y org */
+ 0, /* clip mask */
+ 0, /* dash offset */
+ 4, /* dashes */
+ 1, /* arc mode PieSlice */
+};
+
+void
+CreateGC (
+ FD fd,
+ const unsigned char *buf)
+{
+ CreateValueRec (ILong(buf+4), 23, GCDefaults);
+ SetValueRec (ILong(buf+4), &buf[12], 4, GC_BITMASK, &buf[16]);
+
/* Request CreateGC is opcode 55 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CreateGC */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(4 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + n));
PrintField(buf, 4, 4, GCONTEXT, "graphic-context-id");
PrintField(buf, 8, 4, DRAWABLE, "drawable");
PrintField(buf, 12, 4, GC_BITMASK, "value-mask");
@@ -2275,42 +2390,47 @@ CreateGC(buf)
}
void
-ChangeGC(buf)
- unsigned char *buf;
+ChangeGC (
+ FD fd,
+ const unsigned char *buf)
{
+ SetValueRec (ILong(buf+4), &buf[8], 4, GC_BITMASK, &buf[12]);
+
/* Request ChangeGC is opcode 56 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ChangeGC */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
PrintField(buf, 4, 4, GCONTEXT, "gc");
PrintField(buf, 8, 4, GC_BITMASK, "value-mask");
PrintValues(&buf[8], 4, GC_BITMASK, &buf[12], "value-list");
}
void
-CopyGC(buf)
- unsigned char *buf;
+CopyGC (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CopyGC is opcode 57 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CopyGC */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, GCONTEXT, "src-gc");
PrintField(buf, 8, 4, GCONTEXT, "dst-gc");
PrintField(buf, 12, 4, GC_BITMASK, "value-mask");
}
void
-SetDashes(buf)
- unsigned char *buf;
+SetDashes (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request SetDashes is opcode 58 */
@@ -2318,9 +2438,9 @@ SetDashes(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + (n + p) / 4));
PrintField(buf, 4, 4, GCONTEXT, "gc");
PrintField(buf, 8, 2, CARD16, "dash-offset");
printfield(buf, 10, 2, DVALUE2(n), "length of dashes");
@@ -2329,8 +2449,9 @@ SetDashes(buf)
}
void
-SetClipRectangles(buf)
- unsigned char *buf;
+SetClipRectangles (
+ FD fd,
+ const unsigned char *buf)
{
short n;
@@ -2339,10 +2460,10 @@ SetClipRectangles(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, RECTORDER, "ordering");
- printfield(buf, 2, 2, DVALUE2(3 + 2*n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + 2*n));
n = (IShort(&buf[2]) - 3) / 2;
PrintField(buf, 4, 4, GCONTEXT, "gc");
PrintField(buf, 8, 2, INT16, "clip-x-origin");
@@ -2351,33 +2472,37 @@ SetClipRectangles(buf)
}
void
-FreeGC(buf)
- unsigned char *buf;
+FreeGC (
+ FD fd,
+ const unsigned char *buf)
{
+ DeleteValueRec (ILong (&buf[4]));
+
/* Request FreeGC is opcode 60 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* FreeGC */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, GCONTEXT, "gc");
}
void
-ClearArea(buf)
- unsigned char *buf;
+ClearArea (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ClearArea is opcode 61 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ClearArea */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "exposures");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, WINDOW, "window");
PrintField(buf, 8, 2, INT16, "x");
PrintField(buf, 10, 2, INT16, "y");
@@ -2386,20 +2511,27 @@ ClearArea(buf)
}
void
-CopyArea(buf)
- unsigned char *buf;
+CopyArea (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CopyArea is opcode 62 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CopyArea */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(7), "request length");
+ printreqlen(buf, fd, CONST2(7));
PrintField(buf, 4, 4, DRAWABLE, "src-drawable");
PrintField(buf, 8, 4, DRAWABLE, "dst-drawable");
PrintField(buf, 12, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[12]),
+ GC_function|
+ GC_plane_mask|
+ GC_graphics_exposures,
+ GC_BITMASK);
PrintField(buf, 16, 2, INT16, "src-x");
PrintField(buf, 18, 2, INT16, "src-y");
PrintField(buf, 20, 2, INT16, "dst-x");
@@ -2409,20 +2541,29 @@ CopyArea(buf)
}
void
-CopyPlane(buf)
- unsigned char *buf;
+CopyPlane (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CopyPlane is opcode 63 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CopyPlane */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(8), "request length");
+ printreqlen(buf, fd, CONST2(8));
PrintField(buf, 4, 4, DRAWABLE, "src-drawable");
PrintField(buf, 8, 4, DRAWABLE, "dst-drawable");
PrintField(buf, 12, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[12]),
+ GC_function|
+ GC_plane_mask|
+ GC_foreground|
+ GC_background|
+ GC_graphics_exposures,
+ GC_BITMASK);
PrintField(buf, 16, 2, INT16, "src-x");
PrintField(buf, 18, 2, INT16, "src-y");
PrintField(buf, 20, 2, INT16, "dst-x");
@@ -2433,8 +2574,9 @@ CopyPlane(buf)
}
void
-PolyPoint(buf)
- unsigned char *buf;
+PolyPoint (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolyPoint is opcode 64 */
@@ -2442,19 +2584,26 @@ PolyPoint(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, COORMODE, "coordinate-mode");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
n = (IShort(&buf[2]) - 3);
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, POINT, "points");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_foreground,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, POINT, "points");
}
void
-PolyLine(buf)
- unsigned char *buf;
+PolyLine (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolyLine is opcode 65 */
@@ -2462,19 +2611,34 @@ PolyLine(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, COORMODE, "coordinate-mode");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
n = (IShort(&buf[2]) - 3);
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, POINT, "points");
-}
-
-void
-PolySegment(buf)
- unsigned char *buf;
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_line_width|
+ GC_line_style|
+ GC_cap_style|
+ GC_join_style|
+ GC_fill_style|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, POINT, "points");
+}
+
+void
+PolySegment (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolySegment is opcode 66 */
@@ -2482,18 +2646,32 @@ PolySegment(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + 2*n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + 2*n));
n = (IShort(&buf[2]) - 3) / 2;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, SEGMENT, "segments");
-}
-
-void
-PolyRectangle(buf)
- unsigned char *buf;
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_line_width|
+ GC_line_style|
+ GC_cap_style|
+ GC_fill_style|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, SEGMENT, "segments");
+}
+
+void
+PolyRectangle (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolyRectangle is opcode 67 */
@@ -2501,18 +2679,33 @@ PolyRectangle(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + 2*n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + 2*n));
n = (IShort(&buf[2]) - 3) / 2;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, RECTANGLE, "rectangles");
-}
-
-void
-PolyArc(buf)
- unsigned char *buf;
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_line_width|
+ GC_line_style|
+ GC_cap_style|
+ GC_join_style|
+ GC_fill_style|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, RECTANGLE, "rectangles");
+}
+
+void
+PolyArc (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolyArc is opcode 68 */
@@ -2520,18 +2713,33 @@ PolyArc(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + 3*n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + 3*n));
n = (IShort(&buf[2]) - 3) / 3;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, ARC, "arcs");
-}
-
-void
-FillPoly(buf)
- unsigned char *buf;
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_line_width|
+ GC_line_style|
+ GC_cap_style|
+ GC_join_style|
+ GC_fill_style|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, ARC, "arcs");
+}
+
+void
+FillPoly (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request FillPoly is opcode 69 */
@@ -2539,20 +2747,32 @@ FillPoly(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(4 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + n));
n = (IShort(&buf[2]) - 4);
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong(buf+8),
+ GC_function|
+ GC_plane_mask|
+ GC_fill_style|
+ GC_fill_rule|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
PrintField(buf, 12, 1, POLYSHAPE, "shape");
PrintField(buf, 13, 1, COORMODE, "coordinate-mode");
PrintList(&buf[16], (long)n, POINT, "points");
}
void
-PolyFillRectangle(buf)
- unsigned char *buf;
+PolyFillRectangle (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolyFillRectangle is opcode 70 */
@@ -2560,18 +2780,29 @@ PolyFillRectangle(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + 2*n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + 2*n));
n = (IShort(&buf[2]) - 3) / 2;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, RECTANGLE, "rectangles");
+ if (Verbose > 2)
+ PrintValueRec (ILong(buf+8),
+ GC_function|
+ GC_plane_mask|
+ GC_fill_style|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, RECTANGLE, "rectangles");
}
void
-PolyFillArc(buf)
- unsigned char *buf;
+PolyFillArc (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request PolyFillArc is opcode 71 */
@@ -2579,29 +2810,41 @@ PolyFillArc(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + 3*n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + 3*n));
n = (IShort(&buf[2]) - 3) / 3;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
- PrintList(&buf[12], (long)n, ARC, "arcs");
-}
-
-void
-PutImage(buf)
- unsigned char *buf;
-{
- short n;
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_arc_mode|
+ GC_fill_style|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
+ (void)PrintList(&buf[12], (long)n, ARC, "arcs");
+}
+
+void
+PutImage (
+ FD fd,
+ const unsigned char *buf)
+{
+ int n;
/* Request PutImage is opcode 72 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* PutImage */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, IMAGEMODE, "format");
- printfield(buf, 2, 2, DVALUE2(6 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(6 + (n + p) / 4));
/* the size of the Image is overestimated by the following computation of n,
because we ignore that padding of the request to a multiple of 4 bytes.
@@ -2618,28 +2861,37 @@ PutImage(buf)
n = (IShort(&buf[2]) - 6) * 4;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_foreground|
+ GC_background,
+ GC_BITMASK);
PrintField(buf, 12, 2, CARD16, "width");
PrintField(buf, 14, 2, CARD16, "height");
PrintField(buf, 16, 2, INT16, "dst-x");
PrintField(buf, 18, 2, INT16, "dst-y");
PrintField(buf, 20, 1, CARD8, "left-pad");
PrintField(buf, 21, 1, CARD8, "depth");
- PrintBytes(&buf[24], (long)n, "data");
+ if (Verbose > 3)
+ PrintBytes(&buf[24], (long)n, "data");
}
void
-GetImage(buf)
- unsigned char *buf;
+GetImage (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetImage is opcode 73 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetImage */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, IMAGEMODE, "format");
- printfield(buf, 2, 2, CONST2(5), "request length");
+ printreqlen(buf, fd, CONST2(5));
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 2, INT16, "x");
PrintField(buf, 10, 2, INT16, "y");
@@ -2649,8 +2901,8 @@ GetImage(buf)
}
void
-GetImageReply(buf)
- unsigned char *buf;
+GetImageReply (
+ const unsigned char *buf)
{
long n;
@@ -2666,56 +2918,82 @@ GetImageReply(buf)
length from the length of the reply */
n = ILong(&buf[4]) * 4;
PrintField(buf, 8, 4, VISUALID, "visual");
- PrintBytes(&buf[32], n, "data");
+ if (Verbose > 3)
+ PrintBytes(&buf[32], n, "data");
}
void
-PolyText8(buf)
- unsigned char *buf;
+PolyText8 (
+ FD fd,
+ const unsigned char *buf)
{
- short n;
+ int n;
/* Request PolyText8 is opcode 74 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* PolyText8 */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(4 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + (n + p) / 4));
n = (IShort(&buf[2]) - 4) * 4;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_fill_style|
+ GC_font|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
PrintField(buf, 12, 2, INT16, "x");
PrintField(buf, 14, 2, INT16, "y");
PrintTextList8(&buf[16], n, "items");
}
void
-PolyText16(buf)
- unsigned char *buf;
+PolyText16 (
+ FD fd,
+ const unsigned char *buf)
{
- short n;
+ int n;
/* Request PolyText16 is opcode 75 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* PolyText16 */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(4 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + (n + p) / 4));
n = (IShort(&buf[2]) - 4) * 4;
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_fill_style|
+ GC_font|
+ GC_foreground|
+ GC_background|
+ GC_tile|
+ GC_stipple,
+ GC_BITMASK);
PrintField(buf, 12, 2, INT16, "x");
PrintField(buf, 14, 2, INT16, "y");
PrintTextList16(&buf[16], n, "items");
}
void
-ImageText8(buf)
- unsigned char *buf;
+ImageText8 (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request ImageText8 is opcode 76 */
@@ -2723,21 +3001,29 @@ ImageText8(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
printfield(buf, 1, 1, DVALUE1(n), "length of string");
n = IByte(&buf[1]);
- printfield(buf, 2, 2, DVALUE2(4 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + (n + p) / 4));
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_plane_mask|
+ GC_font|
+ GC_foreground|
+ GC_background,
+ GC_BITMASK);
PrintField(buf, 12, 2, INT16, "x");
PrintField(buf, 14, 2, INT16, "y");
- PrintString8(&buf[16], n, "string");
+ PrintTString8(&buf[16], (long)n, "string");
}
void
-ImageText16(buf)
- unsigned char *buf;
+ImageText16 (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request ImageText16 is opcode 77 */
@@ -2745,115 +3031,128 @@ ImageText16(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
printfield(buf, 1, 1, DVALUE1(n), "length of string");
n = IByte(&buf[1]);
- printfield(buf, 2, 2, DVALUE2(4 + (2*n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + (2*n + p) / 4));
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong (&buf[8]),
+ GC_plane_mask|
+ GC_font|
+ GC_foreground|
+ GC_background,
+ GC_BITMASK);
PrintField(buf, 12, 2, INT16, "x");
PrintField(buf, 14, 2, INT16, "y");
- PrintString16(&buf[16], n, "string");
+ PrintTString16(&buf[16], (long)n, "string");
}
void
-CreateColormap(buf)
- unsigned char *buf;
+CreateColormap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CreateColormap is opcode 78 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CreateColormap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, ALLORNONE, "alloc");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, COLORMAP, "color-map-id");
PrintField(buf, 8, 4, WINDOW, "window");
PrintField(buf, 12, 4, VISUALID, "visual");
}
void
-FreeColormap(buf)
- unsigned char *buf;
+FreeColormap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request FreeColormap is opcode 79 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* FreeColormap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, COLORMAP, "cmap");
}
void
-CopyColormapAndFree(buf)
- unsigned char *buf;
+CopyColormapAndFree (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CopyColormapAndFree is opcode 80 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CopyColormapAndFree */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, COLORMAP, "color-map-id");
PrintField(buf, 8, 4, COLORMAP, "src-cmap");
}
void
-InstallColormap(buf)
- unsigned char *buf;
+InstallColormap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request InstallColormap is opcode 81 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* InstallColormap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, COLORMAP, "cmap");
}
void
-UninstallColormap(buf)
- unsigned char *buf;
+UninstallColormap (
+ FD fd,
+ const unsigned char *buf)
{
/* Request UninstallColormap is opcode 82 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* UninstallColormap */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, COLORMAP, "cmap");
}
void
-ListInstalledColormaps(buf)
- unsigned char *buf;
+ListInstalledColormaps (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ListInstalledColormaps is opcode 83 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ListInstalledColormaps */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, WINDOW, "window");
}
void
-ListInstalledColormapsReply(buf)
- unsigned char *buf;
+ListInstalledColormapsReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* ListInstalledColormaps */ ;
@@ -2867,17 +3166,18 @@ ListInstalledColormapsReply(buf)
}
void
-AllocColor(buf)
- unsigned char *buf;
+AllocColor (
+ FD fd,
+ const unsigned char *buf)
{
/* Request AllocColor is opcode 84 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* AllocColor */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintField(buf, 8, 2, CARD16, "red");
PrintField(buf, 10, 2, CARD16, "green");
@@ -2885,8 +3185,8 @@ AllocColor(buf)
}
void
-AllocColorReply(buf)
- unsigned char *buf;
+AllocColorReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* AllocColor */ ;
if (Verbose < 1)
@@ -2900,8 +3200,9 @@ AllocColorReply(buf)
}
void
-AllocNamedColor(buf)
- unsigned char *buf;
+AllocNamedColor (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request AllocNamedColor is opcode 85 */
@@ -2909,9 +3210,9 @@ AllocNamedColor(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + (n + p) / 4));
PrintField(buf, 4, 4, COLORMAP, "cmap");
printfield(buf, 8, 2, DVALUE2(n), "length of name");
n = IShort(&buf[8]);
@@ -2919,8 +3220,8 @@ AllocNamedColor(buf)
}
void
-AllocNamedColorReply(buf)
- unsigned char *buf;
+AllocNamedColorReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* AllocNamedColor */ ;
if (Verbose < 1)
@@ -2937,26 +3238,27 @@ AllocNamedColorReply(buf)
}
void
-AllocColorCells(buf)
- unsigned char *buf;
+AllocColorCells (
+ FD fd,
+ const unsigned char *buf)
{
/* Request AllocColorCells is opcode 86 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* AllocColorCells */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "contiguous");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintField(buf, 8, 2, CARD16, "colors");
PrintField(buf, 10, 2, CARD16, "planes");
}
void
-AllocColorCellsReply(buf)
- unsigned char *buf;
+AllocColorCellsReply (
+ const unsigned char *buf)
{
short n;
short m;
@@ -2975,18 +3277,19 @@ AllocColorCellsReply(buf)
}
void
-AllocColorPlanes(buf)
- unsigned char *buf;
+AllocColorPlanes (
+ FD fd,
+ const unsigned char *buf)
{
/* Request AllocColorPlanes is opcode 87 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* AllocColorPlanes */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, BOOL, "contiguous");
- printfield(buf, 2, 2, CONST2(4), "request length");
+ printreqlen(buf, fd, CONST2(4));
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintField(buf, 8, 2, CARD16, "colors");
PrintField(buf, 10, 2, CARD16, "reds");
@@ -2995,8 +3298,8 @@ AllocColorPlanes(buf)
}
void
-AllocColorPlanesReply(buf)
- unsigned char *buf;
+AllocColorPlanesReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* AllocColorPlanes */ ;
@@ -3013,8 +3316,9 @@ AllocColorPlanesReply(buf)
}
void
-FreeColors(buf)
- unsigned char *buf;
+FreeColors (
+ FD fd,
+ const unsigned char *buf)
{
short n;
@@ -3023,9 +3327,9 @@ FreeColors(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
n = IShort(&buf[2]) - 3;
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintField(buf, 8, 4, CARD32, "plane-mask");
@@ -3033,8 +3337,9 @@ FreeColors(buf)
}
void
-StoreColors(buf)
- unsigned char *buf;
+StoreColors (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request StoreColors is opcode 89 */
@@ -3042,17 +3347,18 @@ StoreColors(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + 3*n), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + 3*n));
n = (IShort(&buf[2]) - 2) / 3;
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintList(&buf[8], (long)n, COLORITEM, "items");
}
void
-StoreNamedColor(buf)
- unsigned char *buf;
+StoreNamedColor (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request StoreNamedColor is opcode 90 */
@@ -3060,10 +3366,10 @@ StoreNamedColor(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, COLORMASK, "which colors?");
- printfield(buf, 2, 2, DVALUE2(4 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(4 + (n + p) / 4));
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintField(buf, 8, 4, CARD32, "pixel");
printfield(buf, 12, 2, DVALUE2(n), "length of name");
@@ -3072,8 +3378,9 @@ StoreNamedColor(buf)
}
void
-QueryColors(buf)
- unsigned char *buf;
+QueryColors (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request QueryColors is opcode 91 */
@@ -3081,17 +3388,17 @@ QueryColors(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + n));
n = IShort(&buf[2]) - 2;
PrintField(buf, 4, 4, COLORMAP, "cmap");
PrintList(&buf[8], (long)n, CARD32, "pixels");
}
void
-QueryColorsReply(buf)
- unsigned char *buf;
+QueryColorsReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryColors */ ;
@@ -3105,8 +3412,9 @@ QueryColorsReply(buf)
}
void
-LookupColor(buf)
- unsigned char *buf;
+LookupColor (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request LookupColor is opcode 92 */
@@ -3114,9 +3422,9 @@ LookupColor(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + (n + p) / 4));
PrintField(buf, 4, 4, COLORMAP, "cmap");
printfield(buf, 8, 2, DVALUE2(n), "length of name");
n = IShort(&buf[8]);
@@ -3124,8 +3432,8 @@ LookupColor(buf)
}
void
-LookupColorReply(buf)
- unsigned char *buf;
+LookupColorReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* LookupColor */ ;
if (Verbose < 1)
@@ -3141,17 +3449,18 @@ LookupColorReply(buf)
}
void
-CreateCursor(buf)
- unsigned char *buf;
+CreateCursor (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CreateCursor is opcode 93 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CreateCursor */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(8), "request length");
+ printreqlen(buf, fd, CONST2(8));
PrintField(buf, 4, 4, CURSOR, "cursor-id");
PrintField(buf, 8, 4, PIXMAP, "source");
PrintField(buf, 12, 4, PIXMAP, "mask");
@@ -3166,17 +3475,18 @@ CreateCursor(buf)
}
void
-CreateGlyphCursor(buf)
- unsigned char *buf;
+CreateGlyphCursor (
+ FD fd,
+ const unsigned char *buf)
{
/* Request CreateGlyphCursor is opcode 94 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* CreateGlyphCursor */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(8), "request length");
+ printreqlen(buf, fd, CONST2(8));
PrintField(buf, 4, 4, CURSOR, "cursor-id");
PrintField(buf, 8, 4, FONT, "source-font");
PrintField(buf, 12, 4, FONT, "mask-font");
@@ -3191,32 +3501,34 @@ CreateGlyphCursor(buf)
}
void
-FreeCursor(buf)
- unsigned char *buf;
+FreeCursor (
+ FD fd,
+ const unsigned char *buf)
{
/* Request FreeCursor is opcode 95 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* FreeCursor */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, CURSOR, "cursor");
}
void
-RecolorCursor(buf)
- unsigned char *buf;
+RecolorCursor (
+ FD fd,
+ const unsigned char *buf)
{
/* Request RecolorCursor is opcode 96 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* RecolorCursor */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(5), "request length");
+ printreqlen(buf, fd, CONST2(5));
PrintField(buf, 4, 4, CURSOR, "cursor");
PrintField(buf, 8, 2, CARD16, "fore-red");
PrintField(buf, 10, 2, CARD16, "fore-green");
@@ -3227,26 +3539,27 @@ RecolorCursor(buf)
}
void
-QueryBestSize(buf)
- unsigned char *buf;
+QueryBestSize (
+ FD fd,
+ const unsigned char *buf)
{
/* Request QueryBestSize is opcode 97 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* QueryBestSize */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, OBJECTCLASS, "class");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 4, DRAWABLE, "drawable");
PrintField(buf, 8, 2, CARD16, "width");
PrintField(buf, 10, 2, CARD16, "height");
}
void
-QueryBestSizeReply(buf)
- unsigned char *buf;
+QueryBestSizeReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryBestSize */ ;
if (Verbose < 1)
@@ -3258,8 +3571,9 @@ QueryBestSizeReply(buf)
}
void
-QueryExtension(buf)
- unsigned char *buf;
+QueryExtension (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request QueryExtension is opcode 98 */
@@ -3267,17 +3581,17 @@ QueryExtension(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (n + p) / 4));
printfield(buf, 4, 2, DVALUE2(n), "length of name");
n = IShort(&buf[4]);
- PrintString8(&buf[8], n, "name");
+ PrintString8(&buf[8], (long)n, "name");
}
void
-QueryExtensionReply(buf)
- unsigned char *buf;
+QueryExtensionReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* QueryExtension */ ;
if (Verbose < 1)
@@ -3291,22 +3605,23 @@ QueryExtensionReply(buf)
}
void
-ListExtensions(buf)
- unsigned char *buf;
+ListExtensions (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ListExtensions is opcode 99 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ListExtensions */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-ListExtensionsReply(buf)
- unsigned char *buf;
+ListExtensionsReply (
+ const unsigned char *buf)
{
short n;
@@ -3321,8 +3636,9 @@ ListExtensionsReply(buf)
}
void
-ChangeKeyboardMapping(buf)
- unsigned char *buf;
+ChangeKeyboardMapping (
+ FD fd,
+ const unsigned char *buf)
{
short n;
short m;
@@ -3331,11 +3647,11 @@ ChangeKeyboardMapping(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, DVALUE1(n), "keycode-count");
n = IByte(&buf[1]);
- printfield(buf, 2, 2, DVALUE2(2 + nm), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + nm));
PrintField(buf, 4, 1, KEYCODE, "first-keycode");
PrintField(buf, 5, 1, DVALUE1(m), "keysyms-per-keycode");
m = IByte(&buf[5]);
@@ -3343,24 +3659,25 @@ ChangeKeyboardMapping(buf)
}
void
-GetKeyboardMapping(buf)
- unsigned char *buf;
+GetKeyboardMapping (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetKeyboardMapping is opcode 101 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetKeyboardMapping */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 1, KEYCODE, "first-keycode");
PrintField(buf, 5, 1, CARD8, "count");
}
void
-GetKeyboardMappingReply(buf)
- unsigned char *buf;
+GetKeyboardMappingReply (
+ const unsigned char *buf)
{
long n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetKeyboardMapping */ ;
@@ -3374,38 +3691,40 @@ GetKeyboardMappingReply(buf)
}
void
-ChangeKeyboardControl(buf)
- unsigned char *buf;
+ChangeKeyboardControl (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ChangeKeyboardControl is opcode 102 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ChangeKeyboardControl */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(2 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + n));
PrintField(buf, 4, 4, KEYBOARD_BITMASK, "value-mask");
PrintValues(&buf[4], 4, KEYBOARD_BITMASK, &buf[8], "value-list");
}
void
-GetKeyboardControl(buf)
- unsigned char *buf;
+GetKeyboardControl (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetKeyboardControl is opcode 103 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetKeyboardControl */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-GetKeyboardControlReply(buf)
- unsigned char *buf;
+GetKeyboardControlReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetKeyboardControl */ ;
if (Verbose < 1)
@@ -3422,32 +3741,34 @@ GetKeyboardControlReply(buf)
}
void
-Bell(buf)
- unsigned char *buf;
+Bell (
+ FD fd,
+ const unsigned char *buf)
{
/* Request Bell is opcode 104 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* Bell */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, INT8, "percent");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-ChangePointerControl(buf)
- unsigned char *buf;
+ChangePointerControl (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ChangePointerControl is opcode 105 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ChangePointerControl */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 2, INT16, "acceleration-numerator");
PrintField(buf, 6, 2, INT16, "acceleration-denominator");
PrintField(buf, 8, 2, INT16, "threshold");
@@ -3456,22 +3777,23 @@ ChangePointerControl(buf)
}
void
-GetPointerControl(buf)
- unsigned char *buf;
+GetPointerControl (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetPointerControl is opcode 106 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetPointerControl */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-GetPointerControlReply(buf)
- unsigned char *buf;
+GetPointerControlReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetPointerControl */ ;
if (Verbose < 1)
@@ -3484,17 +3806,18 @@ GetPointerControlReply(buf)
}
void
-SetScreenSaver(buf)
- unsigned char *buf;
+SetScreenSaver (
+ FD fd,
+ const unsigned char *buf)
{
/* Request SetScreenSaver is opcode 107 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* SetScreenSaver */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(3), "request length");
+ printreqlen(buf, fd, CONST2(3));
PrintField(buf, 4, 2, INT16, "timeout");
PrintField(buf, 6, 2, INT16, "interval");
PrintField(buf, 8, 1, NO_YES, "prefer-blanking");
@@ -3502,22 +3825,23 @@ SetScreenSaver(buf)
}
void
-GetScreenSaver(buf)
- unsigned char *buf;
+GetScreenSaver (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetScreenSaver is opcode 108 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetScreenSaver */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-GetScreenSaverReply(buf)
- unsigned char *buf;
+GetScreenSaverReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetScreenSaver */ ;
if (Verbose < 1)
@@ -3531,8 +3855,9 @@ GetScreenSaverReply(buf)
}
void
-ChangeHosts(buf)
- unsigned char *buf;
+ChangeHosts (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request ChangeHosts is opcode 109 */
@@ -3540,10 +3865,10 @@ ChangeHosts(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, INS_DEL, "mode");
- printfield(buf, 2, 2, DVALUE2(2 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(2 + (n + p) / 4));
n = IShort(&buf[6]);
#if 0
PrintField(buf, 4, 1, HOSTFAMILY, "family");
@@ -3555,22 +3880,23 @@ ChangeHosts(buf)
}
void
-ListHosts(buf)
- unsigned char *buf;
+ListHosts (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ListHosts is opcode 110 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ListHosts */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-ListHostsReply(buf)
- unsigned char *buf;
+ListHostsReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* ListHosts */ ;
@@ -3585,53 +3911,57 @@ ListHostsReply(buf)
}
void
-SetAccessControl(buf)
- unsigned char *buf;
+SetAccessControl (
+ FD fd,
+ const unsigned char *buf)
{
/* Request SetAccessControl is opcode 111 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* SetAccessControl */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, DIS_EN, "mode");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-SetCloseDownMode(buf)
- unsigned char *buf;
+SetCloseDownMode (
+ FD fd,
+ const unsigned char *buf)
{
/* Request SetCloseDownMode is opcode 112 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* SetCloseDownMode */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, CLOSEMODE, "mode");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-KillClient(buf)
- unsigned char *buf;
+KillClient (
+ FD fd,
+ const unsigned char *buf)
{
/* Request KillClient is opcode 113 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* KillClient */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(2), "request length");
+ printreqlen(buf, fd, CONST2(2));
PrintField(buf, 4, 4, RESOURCEID, "resource");
}
void
-RotateProperties(buf)
- unsigned char *buf;
+RotateProperties (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request RotateProperties is opcode 114 */
@@ -3639,9 +3969,9 @@ RotateProperties(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, DVALUE2(3 + n), "request length");
+ printreqlen(buf, fd, DVALUE2(3 + n));
PrintField(buf, 4, 4, WINDOW, "window");
printfield(buf, 8, 2, DVALUE2(n), "number of properties");
n = IShort(&buf[8]);
@@ -3650,23 +3980,25 @@ RotateProperties(buf)
}
void
-ForceScreenSaver(buf)
- unsigned char *buf;
+ForceScreenSaver (
+ FD fd,
+ const unsigned char *buf)
{
/* Request ForceScreenSaver is opcode 115 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* ForceScreenSaver */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, SAVEMODE, "mode");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-SetPointerMapping(buf)
- unsigned char *buf;
+SetPointerMapping (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request SetPointerMapping is opcode 116 */
@@ -3674,17 +4006,17 @@ SetPointerMapping(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
printfield(buf, 1, 1, DVALUE1(n), "length of map");
n = IByte(&buf[1]);
- printfield(buf, 2, 2, DVALUE2(1 + (n + p) / 4), "request length");
+ printreqlen(buf, fd, DVALUE2(1 + (n + p) / 4));
PrintBytes(&buf[4], (long)n,"map");
}
void
-SetPointerMappingReply(buf)
- unsigned char *buf;
+SetPointerMappingReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* SetPointerMapping */ ;
if (Verbose < 1)
@@ -3695,22 +4027,23 @@ SetPointerMappingReply(buf)
}
void
-GetPointerMapping(buf)
- unsigned char *buf;
+GetPointerMapping (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetPointerMapping is opcode 117 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetPointerMapping */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-GetPointerMappingReply(buf)
- unsigned char *buf;
+GetPointerMappingReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetPointerMapping */ ;
@@ -3724,8 +4057,9 @@ GetPointerMappingReply(buf)
}
void
-SetModifierMapping(buf)
- unsigned char *buf;
+SetModifierMapping (
+ FD fd,
+ const unsigned char *buf)
{
short n;
/* Request SetModifierMapping is opcode 118 */
@@ -3733,11 +4067,11 @@ SetModifierMapping(buf)
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
PrintField(buf, 1, 1, DVALUE1(n), "keycodes-per-modifier");
n = IByte(&buf[1]);
- printfield(buf, 2, 2, DVALUE2(1 + 2*n), "request length");
+ printreqlen(buf, fd, DVALUE2(1 + 2*n));
PrintBytes(&buf[4 + 0 * n], (long)n,"Shift keycodes");
PrintBytes(&buf[4 + 1 * n], (long)n,"Lock keycodes");
PrintBytes(&buf[4 + 2 * n], (long)n,"Control keycodes");
@@ -3749,8 +4083,8 @@ SetModifierMapping(buf)
}
void
-SetModifierMappingReply(buf)
- unsigned char *buf;
+SetModifierMappingReply (
+ const unsigned char *buf)
{
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* SetModifierMapping */ ;
if (Verbose < 1)
@@ -3761,22 +4095,23 @@ SetModifierMappingReply(buf)
}
void
-GetModifierMapping(buf)
- unsigned char *buf;
+GetModifierMapping (
+ FD fd,
+ const unsigned char *buf)
{
/* Request GetModifierMapping is opcode 119 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* GetModifierMapping */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
void
-GetModifierMappingReply(buf)
- unsigned char *buf;
+GetModifierMappingReply (
+ const unsigned char *buf)
{
short n;
PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetModifierMapping */ ;
@@ -3790,15 +4125,16 @@ GetModifierMappingReply(buf)
}
void
-NoOperation(buf)
- unsigned char *buf;
+NoOperation (
+ FD fd,
+ const unsigned char *buf)
{
/* Request NoOperation is opcode 127 */
PrintField(buf, 0, 1, REQUEST, REQUESTHEADER) /* NoOperation */ ;
if (Verbose < 1)
return;
if (Verbose > 1)
- PrintField(SBf, 0, 4, INT32, "sequence number");
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
- printfield(buf, 2, 2, CONST2(1), "request length");
+ printreqlen(buf, fd, CONST2(1));
}
diff --git a/print_bigreq.c b/print_bigreq.c
new file mode 100644
index 0000000..7871826
--- /dev/null
+++ b/print_bigreq.c
@@ -0,0 +1,51 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "scope.h"
+#include "x11.h"
+#include "bigreqscope.h"
+
+void
+BigreqEnable (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* BigreqRequest */ ;
+ PrintField (buf, 1, 1, BIGREQREQUEST, BIGREQREQUESTHEADER) /* BigreqSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+BigreqEnableReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* BigreqRequest reply */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 4, CARD32, "max-request-size");
+}
diff --git a/print_lbx.c b/print_lbx.c
new file mode 100644
index 0000000..2ec880c
--- /dev/null
+++ b/print_lbx.c
@@ -0,0 +1,210 @@
+/*
+ * $NCDId$
+ *
+ * Copyright 1992 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+#include "scope.h"
+#include "x11.h"
+#include "lbxscope.h"
+
+static unsigned long sequences[256];
+static unsigned char starting_server[256];
+static unsigned char starting_client[256];
+static int client_client, server_client;
+
+void
+LbxQueryVersion (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* LbxRequest */ ;
+ PrintField (buf, 1, 1, LBXREQUEST, LBXREQUESTHEADER) /* LbxSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+LbxQueryVersionReply (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* LbxRequest reply */ ;
+ PrintField(RBf, 1, 1, LBXREPLY, LBXREPLYHEADER) /* LbxQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 2, CARD16, "major-version");
+ PrintField(buf, 10, 2, CARD16, "minor-version");
+}
+
+void
+LbxStartProxy (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* LbxRequest */ ;
+ PrintField (buf, 1, 1, LBXREQUEST, LBXREQUESTHEADER) /* LbxSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+LbxStopProxy (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* LbxRequest */ ;
+ PrintField (buf, 1, 1, LBXREQUEST, LBXREQUESTHEADER) /* LbxSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+LbxNewClient (
+ FD fd,
+ const unsigned char *buf)
+{
+ unsigned long c;
+
+ c = ILong(&buf[4]);
+ starting_client[c] = 1;
+ starting_server[c] = 1;
+ sequences[c] = 0;
+
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* LbxRequest */ ;
+ PrintField (buf, 1, 1, LBXREQUEST, LBXREQUESTHEADER) /* LbxSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, CARD32, "new-client-id");
+}
+
+void
+LbxCloseClient (
+ FD fd,
+ const unsigned char *buf)
+{
+}
+
+void
+LbxSwitch (
+ FD fd,
+ const unsigned char *buf)
+{
+ unsigned long c;
+ c = ILong(&buf[4]);
+ CS[fd].SequenceNumber--;
+ sequences[client_client] = CS[fd].SequenceNumber;
+ if (starting_client[c])
+ {
+ CS[fd].ByteProcessing = StartSetUpMessage;
+ CS[fd].NumberofBytesNeeded = 12;
+ starting_client[c] = 0;
+ }
+ CS[fd].SequenceNumber = sequences[c];
+ client_client = c;
+
+
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* LbxRequest */ ;
+ PrintField (buf, 1, 1, LBXREQUEST, LBXREQUESTHEADER) /* LbxSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, CARD32, "client number");
+}
+
+void
+LbxModifySequence (
+ FD fd,
+ const unsigned char *buf)
+{
+ int mod;
+
+ mod = ILong(&buf[4]);
+ CS[fd].SequenceNumber += mod;
+
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* LbxRequest */ ;
+ PrintField (buf, 1, 1, LBXREQUEST, LBXREQUESTHEADER) /* LbxModifySequence */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ printfield(buf, 4, 4, INT32, "adjustment");
+}
+
+void
+LbxSwitchEvent (
+ FD fd,
+ const unsigned char *buf)
+{
+ unsigned long c;
+
+ c = ILong(&buf[4]);
+ if (starting_server[c])
+ {
+ CS[fd].ByteProcessing = StartSetUpReply;
+ CS[fd].NumberofBytesNeeded = 8;
+ starting_server[c] = 0;
+ }
+
+ PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* LbxEvent */ ;
+ PrintField(buf, 1, 1, LBXEVENT, LBXEVENTHEADER) /* LbxSwitchEvent */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, CARD32, "client");
+}
+
+void
+LbxCloseEvent (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* LbxEvent */ ;
+ PrintField(buf, 1, 1, LBXEVENT, LBXEVENTHEADER) /* LbxSwitchEvent */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, CARD32, "client");
+}
diff --git a/print_randr.c b/print_randr.c
new file mode 100644
index 0000000..f987ebc
--- /dev/null
+++ b/print_randr.c
@@ -0,0 +1,168 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "scope.h"
+#include "x11.h"
+#include "randrscope.h"
+
+void
+RandrQueryVersion (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RandrRequest */ ;
+ PrintField (buf, 1, 1, RANDRREQUEST, RANDRREQUESTHEADER) /* RandrSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RandrQueryVersionReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RandrRequest reply */ ;
+ PrintField(RBf, 1, 1, RANDRREPLY, RANDRREPLYHEADER) /* RandrQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 2, CARD16, "major-version");
+ PrintField(buf, 10, 2, CARD16, "minor-version");
+}
+
+void
+RandrGetScreenInfo (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RandrRequest */ ;
+ PrintField (buf, 1, 1, RANDRREQUEST, RANDRREQUESTHEADER) /* RandrSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, WINDOW, "window");
+}
+
+void
+RandrGetScreenInfoReply (FD fd, const unsigned char *buf)
+{
+ unsigned short nsize;
+ unsigned short nvg;
+ unsigned short ngvg;
+
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RandrRequest reply */ ;
+ if (Verbose < 1)
+ return;
+ PrintField(buf, 1, 1, CARD8, "set-of-rotations");
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 4, WINDOW, "root");
+ PrintField(buf,12, 4, TIMESTAMP, "timestamp");
+ PrintField(buf,16, 4, TIMESTAMP, "config-timestamp");
+ PrintField(buf,20, 2, CARD16, "num-visual-groups");
+ nvg = IShort (&buf[20]);
+ PrintField(buf,22, 2, CARD16, "num-groups-of-visual-groups");
+ ngvg = IShort (&buf[22]);
+ PrintField(buf,24, 2, CARD16, "num-sizes");
+ nsize = IShort (&buf[24]);
+ PrintField(buf,26, 2, CARD16, "size-id");
+ PrintField(buf,28, 2, CARD16, "visual-group-id");
+ PrintField(buf,30, 2, CARD16, "rotation");
+}
+
+void
+RandrSetScreenConfig (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RandrRequest */ ;
+ PrintField (buf, 1, 1, RANDRREQUEST, RANDRREQUESTHEADER) /* RandrSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, DRAWABLE, "drawable");
+ PrintField(buf, 8, 4, TIMESTAMP, "timestamp");
+ PrintField(buf,12, 4, TIMESTAMP, "config-timestamp");
+ PrintField(buf,16, 2, CARD16, "size-id");
+ PrintField(buf,18, 2, CARD16, "rotation");
+ PrintField(buf,20, 2, CARD16, "visual-group-id");
+}
+
+void
+RandrSetScreenConfigReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RandrRequest reply */ ;
+ PrintField(buf, 1, 1, BOOL, "success") /* RandrQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 4, TIMESTAMP, "new-timestamp");
+ PrintField(buf,12, 4, TIMESTAMP, "new-config-timestamp");
+ PrintField(buf,16, 4, WINDOW, "root");
+}
+
+void
+RandrScreenChangeSelectInput (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RandrRequest */ ;
+ PrintField (buf, 1, 1, RANDRREQUEST, RANDRREQUESTHEADER) /* RandrSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, WINDOW, "window");
+ PrintField(buf, 8, 1, BOOL, "enable");
+}
+
+void
+RandrScreenSizes (const unsigned char *buf)
+{
+ PrintField(buf, 0, 2, CARD16, "width-in-pixels");
+ PrintField(buf, 2, 2, CARD16, "height-in-pixels");
+ PrintField(buf, 4, 2, CARD16, "width-in-millimeters");
+ PrintField(buf, 6, 2, CARD16, "height-in-millimeters");
+ PrintField(buf, 8, 2, CARD16, "visual-group");
+}
+
+void
+RandrScreenChangeNotifyEvent (const unsigned char *buf)
+{
+ PrintField(buf, 0, 1, EVENT, EVENTHEADER) /* RRScreenChangeNotify */ ;
+ if (Verbose < 1)
+ return;
+ PrintField(buf, 1, 1, BOOL, "resident");
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, TIMESTAMP, "timestamp");
+ PrintField(buf, 8, 4, TIMESTAMP, "config-timestamp");
+ PrintField(buf,12, 4, WINDOW, "root");
+ PrintField(buf,16, 2, CARD16, "size id");
+ PrintField(buf,18, 2, CARD16, "rotation");
+ RandrScreenSizes (buf + 20);
+}
diff --git a/print_render.c b/print_render.c
new file mode 100644
index 0000000..212fc27
--- /dev/null
+++ b/print_render.c
@@ -0,0 +1,631 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "scope.h"
+#include "x11.h"
+#include "renderscope.h"
+
+void
+RenderQueryVersion (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderQueryVersionReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RenderRequest reply */ ;
+ PrintField(RBf, 1, 1, RENDERREPLY, RENDERREPLYHEADER) /* RenderQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 2, CARD16, "major-version");
+ PrintField(buf, 10, 2, CARD16, "minor-version");
+}
+
+void
+RenderQueryPictFormats (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderQueryPictFormatsReply (FD fd, const unsigned char *buf)
+{
+ long n;
+ long f;
+ long s;
+ long d;
+ long v;
+
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RenderRequest reply */ ;
+ PrintField(RBf, 1, 1, RENDERREPLY, RENDERREPLYHEADER) /* RenderQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ n = ILong (&buf[4]);
+ f = ILong (&buf[8]);
+ s = ILong (&buf[12]);
+ d = ILong (&buf[16]);
+ v = ILong (&buf[20]);
+ PrintList (&buf[32], (long) f, PICTFORMINFO, "pict-formats");
+}
+
+void
+RenderQueryPictIndexValues (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderQueryPictIndexValuesReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RenderRequest reply */ ;
+ PrintField(RBf, 1, 1, RENDERREPLY, RENDERREPLYHEADER) /* RenderQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+}
+
+void
+RenderQueryDithers (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderQueryDithersReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* RenderRequest reply */ ;
+ PrintField(RBf, 1, 1, RENDERREPLY, RENDERREPLYHEADER) /* RenderQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+}
+
+void
+RenderCreatePicture (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, DVALUE2(5+n));
+ PrintField(buf, 4, 4, PICTURE, "picture");
+ PrintField(buf, 8, 4, DRAWABLE, "drawable");
+ PrintField(buf, 12, 4, PICTFORMAT, "format");
+ PrintField(buf, 16, 4, PICTURE_BITMASK, "value-mask");
+ PrintValues(&buf[16], 4, PICTURE_BITMASK, &buf[20], "value-list");
+}
+
+void
+RenderChangePicture (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, DVALUE2(3+n));
+ PrintField(buf, 4, 4, PICTURE, "picture");
+ PrintField(buf, 8, 4, PICTURE_BITMASK, "value-mask");
+ PrintValues(&buf[8], 4, PICTURE_BITMASK, &buf[12], "value-list");
+}
+
+void
+RenderSetPictureClipRectangles (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderFreePicture (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderComposite (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderScale (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderTrapezoids (FD fd, const unsigned char *buf)
+{
+ int n;
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField (buf, 4, 1, PICTOP, "op");
+ PrintField(buf, 8, 4, PICTURE, "source");
+ PrintField(buf, 12, 4, PICTURE, "dest");
+ PrintField(buf, 16, 4, PICTFORMAT, "mask format");
+ PrintField(buf, 20, 2, CARD16, "source x");
+ PrintField(buf, 22, 2, CARD16, "source y");
+ n = (CS[fd].requestLen - 6) / 10;
+ PrintList(&buf[24], (long)n, TRAPEZOID, "trapezoids");
+}
+
+void
+RenderTriangles (FD fd, const unsigned char *buf)
+{
+ long n;
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField (buf, 4, 1, PICTOP, "op");
+ PrintField(buf, 8, 4, PICTURE, "source");
+ PrintField(buf, 12, 4, PICTURE, "dest");
+ PrintField(buf, 16, 4, PICTFORMAT, "mask format");
+ PrintField(buf, 20, 2, CARD16, "source x");
+ PrintField(buf, 22, 2, CARD16, "source y");
+ n = (CS[fd].requestLen - 6) / 6;
+ PrintList(&buf[24], (long)n, TRIANGLE, "triangles");
+}
+
+void
+RenderTriStrip (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderTriFan (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderColorTrapezoids (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderColorTriangles (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderTransform (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderCreateGlyphSet (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, GLYPHSET, "glyphset");
+ PrintField(buf, 8, 4, PICTFORMAT, "format");
+}
+
+void
+RenderReferenceGlyphSet (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+RenderFreeGlyphSet (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, GLYPHSET, "glyphset");
+}
+
+static void
+PrintGlyphs(const unsigned char *buf, int n, char *name)
+{
+ const unsigned char *gids;
+ const unsigned char *glyphs;
+ int i;
+
+ fprintf(stdout, "%s%20s:\n", Leader, name);
+ gids = buf;
+ glyphs = gids + 4 * n;
+ for (i = 0; i < n; i++)
+ {
+ PrintField(gids, 0, 4, CARD32, "glyphid");
+ PrintField(glyphs, 0, 2, CARD16, "width");
+ PrintField(glyphs, 2, 2, CARD16, "height");
+ PrintField(glyphs, 4, 2, INT16, "x");
+ PrintField(glyphs, 6, 2, INT16, "y");
+ PrintField(glyphs, 8, 2, INT16, "xOff");
+ PrintField(glyphs, 10, 2, INT16, "yOff");
+ glyphs += 12;
+ }
+}
+
+void
+RenderAddGlyphs (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, GLYPHSET, "glyphset");
+ PrintField(buf, 8, 4, CARD32, "nglyphs");
+ PrintGlyphs(&buf[12], ILong(&buf[8]), "glyphs");
+}
+
+void
+RenderAddGlyphsFromPicture (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+
+}
+
+void
+RenderFreeGlyphs (FD fd, const unsigned char *buf)
+{
+ unsigned short n;
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, GLYPHSET, "glyphset");
+ n = (IShort(&buf[2]) - 2);
+ (void)PrintList(&buf[8], (long)n, CARD32, "glyphs");
+}
+
+static void
+PrintGlyphList(const unsigned char *buf, int length, char *name, int size)
+{
+ short n;
+
+ fprintf(stdout, "%s%20s:\n", Leader, name);
+ while (length >= 8)
+ {
+ n = IByte(&buf[0]);
+ if (n != 255)
+ {
+ printfield(buf, 0, 1, CARD8, "length");
+ PrintField(buf, 4, 2, INT16, "delta x");
+ PrintField(buf, 6, 2, INT16, "delta y");
+ switch (size) {
+ case 1:
+ PrintTString8(&buf[8], (long) n, "glyph item 8 string"); break;
+ case 2:
+ PrintTString16(&buf[8], (long) n, "glyph item 16 string"); break;
+ case 4:
+ break;
+ }
+ n = ((n * size + 8) + 3) & ~3;
+ buf += n;
+ length -= n;
+ }
+ else
+ {
+ PrintField(buf, 8, 4, GLYPHSET, "glyphset");
+ buf += 12;
+ length -= 12;
+ }
+ }
+}
+
+void
+RenderCompositeGlyphs8 (FD fd, const unsigned char *buf)
+{
+ int n;
+
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ n = (CS[fd].requestLen - 7) * 4;
+ PrintField(buf, 4, 1, PICTOP, "op");
+ PrintField(buf, 8, 4, PICTURE, "source");
+ PrintField(buf, 12, 4, PICTURE, "dest");
+ PrintField(buf, 16, 4, PICTFORMAT, "mask format");
+ PrintField(buf, 20, 4, GLYPHSET, "glyphset");
+ PrintField(buf, 24, 2, INT16, "x-src");
+ PrintField(buf, 26, 2, INT16, "y-src");
+ PrintGlyphList(&buf[28], n, "items", 1);
+}
+
+void
+RenderCompositeGlyphs16 (FD fd, const unsigned char *buf)
+{
+ int n;
+
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ n = (CS[fd].requestLen - 7) * 4;
+
+ PrintField(buf, 4, 1, PICTOP, "op");
+ PrintField(buf, 8, 4, PICTURE, "source");
+ PrintField(buf, 12, 4, PICTURE, "dest");
+ PrintField(buf, 16, 4, PICTFORMAT, "mask format");
+ PrintField(buf, 20, 4, GLYPHSET, "glyphset");
+ PrintField(buf, 24, 2, INT16, "x-src");
+ PrintField(buf, 26, 2, INT16, "y-src");
+ PrintGlyphList(&buf[28], n, "items", 2);
+}
+
+void
+RenderCompositeGlyphs32 (FD fd, const unsigned char *buf)
+{
+ int n;
+
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ n = (CS[fd].requestLen - 7) * 4;
+ PrintField(buf, 4, 1, PICTOP, "op");
+ PrintField(buf, 8, 4, PICTURE, "source");
+ PrintField(buf, 12, 4, PICTURE, "dest");
+ PrintField(buf, 16, 4, PICTFORMAT, "mask format");
+ PrintField(buf, 20, 4, GLYPHSET, "glyphset");
+ PrintField(buf, 24, 2, INT16, "x-src");
+ PrintField(buf, 26, 2, INT16, "y-src");
+ PrintGlyphList(&buf[28], n, "items", 4);
+}
+
+void
+RenderFillRectangles (FD fd, const unsigned char *buf)
+{
+ int n;
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* RenderRequest */ ;
+ PrintField (buf, 1, 1, RENDERREQUEST, RENDERREQUESTHEADER) /* RenderSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ n = (CS[fd].requestLen - 5) / 2;
+ PrintField(buf, 4, 1, PICTOP, "op");
+ PrintField(buf, 8, 4, PICTURE, "dest");
+ PrintField(buf, 12, 8, RENDERCOLOR, "color");
+ (void)PrintList(&buf[20], (long)n, RECTANGLE, "rectangles");
+}
+
+void
+RenderPictFormatError (FD fd, const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, PICTFORMAT, "format");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+void
+RenderPictureError (FD fd, const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, PICTURE, "picture");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+void
+RenderPictOpError (FD fd, const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, PICTOP, "pictop");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+void
+RenderGlyphSetError (FD fd, const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, GLYPHSET, "glyphset");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+void
+RenderGlyphError (FD fd, const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, CARD32, "glyph");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
diff --git a/print_shm.c b/print_shm.c
new file mode 100644
index 0000000..02a30d9
--- /dev/null
+++ b/print_shm.c
@@ -0,0 +1,174 @@
+/*
+ * $XFree86$
+ *
+ * Copyright <20> 2001 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Keith Packard makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "scope.h"
+#include "x11.h"
+#include "shmscope.h"
+
+void
+MitshmQueryVersion (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* MitshmRequest */ ;
+ PrintField (buf, 1, 1, MITSHMREQUEST, MITSHMREQUESTHEADER) /* MitshmSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+MitshmQueryVersionReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* MitshmRequest reply */ ;
+ if (Verbose < 1)
+ return;
+ PrintField(RBf, 1, 1, BOOL, "shared-pixmaps") /* shared Pixmaps */;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 2, CARD16, "major-version");
+ PrintField(buf, 10, 2, CARD16, "minor-version");
+ PrintField(buf, 12, 2, CARD16, "uid");
+ PrintField(buf, 14, 2, CARD16, "gid");
+ PrintField(buf, 16, 1, CARD8, "pxiamp-fromat");
+}
+
+void
+MitshmAttach (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* MitshmRequest */ ;
+ PrintField (buf, 1, 1, MITSHMREQUEST, MITSHMREQUESTHEADER) /* MitshmSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, CARD32, "shmseg");
+ PrintField(buf, 8, 4, CARD32, "shmid");
+ PrintField(buf, 12, 1, BOOL, "read-only");
+}
+
+void
+MitshmDetach (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* MitshmRequest */ ;
+ PrintField (buf, 1, 1, MITSHMREQUEST, MITSHMREQUESTHEADER) /* MitshmSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField (buf, 4, 4, CARD32, "shmseg");
+}
+
+void
+MitshmPutImage (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* MitshmRequest */ ;
+ PrintField (buf, 1, 1, MITSHMREQUEST, MITSHMREQUESTHEADER) /* MitshmSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField (buf, 4, 4, DRAWABLE, "drawable");
+ PrintField (buf, 8, 4, GCONTEXT, "gc");
+ PrintField (buf, 12, 2, CARD16, "total-width");
+ PrintField (buf, 14, 2, CARD16, "total-width");
+ PrintField (buf, 16, 2, CARD16, "src-x");
+ PrintField (buf, 18, 2, CARD16, "src-y");
+ PrintField (buf, 20, 2, CARD16, "src-width");
+ PrintField (buf, 22, 2, CARD16, "src-height");
+ PrintField (buf, 24, 2, INT16, "dst-x");
+ PrintField (buf, 26, 2, INT16, "dst-y");
+ PrintField (buf, 28, 1, CARD8, "depth");
+ PrintField (buf, 29, 1, CARD8, "format");
+ PrintField (buf, 30, 1, BOOL, "send-event");
+ PrintField (buf, 31, 1, CARD8, "bpad");
+ PrintField (buf, 32, 4, CARD32, "shmseg");
+ PrintField (buf, 36, 4, CARD32, "offset");
+}
+
+void
+MitshmGetImage (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* MitshmRequest */ ;
+ PrintField (buf, 1, 1, MITSHMREQUEST, MITSHMREQUESTHEADER) /* MitshmSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, DVALUE2(5+n));
+ PrintField (buf, 4, 4, DRAWABLE, "drawable");
+ PrintField (buf, 8, 2, INT16, "x");
+ PrintField (buf, 10, 2, INT16, "y");
+ PrintField (buf, 12, 2, CARD16, "width");
+ PrintField (buf, 14, 2, CARD16, "height");
+ PrintField (buf, 16, 4, CARD32, "planemask");
+ PrintField (buf, 20, 1, CARD8, "format");
+ PrintField (buf, 24, 4, CARD32, "shmseg");
+ PrintField (buf, 28, 4, CARD32, "shmseg");
+}
+
+void
+MitshmGetImageReply (FD fd, const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* MitshmRequest reply */ ;
+ if (Verbose < 1)
+ return;
+ PrintField(RBf, 1, 1, CARD8, "depth") /* shared Pixmaps */;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 4, VISUALID, "visual");
+}
+
+void
+MitshmCreatePixmap (FD fd, const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* MitshmRequest */ ;
+ PrintField (buf, 1, 1, MITSHMREQUEST, MITSHMREQUESTHEADER) /* MitshmSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, DVALUE2(3+n));
+ PrintField(buf, 4, 4, PIXMAP, "pid");
+ PrintField(buf, 8, 4, DRAWABLE, "drawable");
+ PrintField(buf, 12, 2, CARD16, "width");
+ PrintField(buf, 14, 2, CARD16, "height");
+ PrintField(buf, 16, 1, CARD8, "depth");
+ PrintField(buf, 20, 4, CARD32, "shmseg");
+ PrintField(buf, 24, 4, CARD32, "offset");
+}
+
+void
+MitshmShmSegError (FD fd, const unsigned char *buf)
+{
+}
diff --git a/print_wcp.c b/print_wcp.c
new file mode 100644
index 0000000..b9bbbc3
--- /dev/null
+++ b/print_wcp.c
@@ -0,0 +1,464 @@
+/*
+ * $NCDOr: print_wcp.c,v 1.1 1996/07/18 23:26:38 keithp Exp keithp $
+ *
+ * Copyright 1996 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+#include "scope.h"
+#include "x11.h"
+#include "wcpscope.h"
+
+void
+WcpQueryVersion (
+ FD fd,
+ register const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+WcpQueryVersionReply (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* WcpRequest reply */ ;
+ PrintField(RBf, 1, 1, WCPREPLY, WCPREPLYHEADER) /* WcpQueryVersion reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(0), "reply length");
+ PrintField(buf, 8, 2, CARD16, "major-version");
+ PrintField(buf, 10, 2, CARD16, "minor-version");
+}
+
+#define NextByte(dst) if (!len--) { error = "Out of data"; break; } dst = *data++;
+
+static void
+WcpAnalyzeImage1RLL (
+ const char *buf,
+ int len,
+ int width,
+ int height)
+{
+ unsigned char byte;
+ unsigned char *data = (unsigned char *) buf;
+ int x, y;
+ const char *error = NULL;
+ int bytewidth;
+ int i;
+ int w;
+
+ y = 0;
+ bytewidth = (width + 7) >> 3;
+ while (!error && height--)
+ {
+ x = 0;
+ if (Verbose > 2)
+ fprintf (stdout, "%s %9d %9d:", Leader, y, (char *) data - buf);
+ NextByte (byte);
+ if (Verbose > 2)
+ fprintf (stdout, " %2x", byte);
+ switch (byte) {
+ case 0xff:
+ for (i = 0; i < bytewidth; i++)
+ {
+ NextByte(byte);
+ }
+ break;
+ default:
+ w = width;
+ while (w)
+ {
+ NextByte(byte);
+ if (Verbose > 2)
+ fprintf (stdout, " %3d", byte);
+ if (byte > w)
+ {
+ error = "bad run";
+ break;
+ }
+ x += byte;
+ w -= byte;
+ }
+ break;
+ }
+ if (Verbose > 2)
+ fprintf (stdout, "\n");
+ y++;
+ }
+ if (error)
+ fprintf (stdout, "%s%20s: %d, %d %d\n", Leader, error,
+ x, y - 1, (char *) data - buf);
+}
+
+static void
+WcpAnalyzeImageNRLL (
+ const char *buf,
+ int len,
+ int width,
+ int height,
+ int bytes)
+{
+}
+
+#define MAX_LRU_SHORT 0xe
+#define LRU_LONG 0xf
+#define MAX_LRU_RUN (MAX_LRU_SHORT + 0xff)
+
+#define LRU_CACHE 0xf
+#define LRU_MISS 0xf
+
+typedef unsigned long PIXEL;
+
+static void
+init_cache (
+ PIXEL cache[LRU_CACHE],
+ int BPP)
+{
+ int e;
+
+ /*
+ * initialize cache values
+ */
+ for (e = 0; e < 8; e++)
+ {
+ cache[e] = e;
+ cache[LRU_CACHE-e-1] = ((1 << BPP) - 1) - e;
+ }
+}
+
+static void
+push (
+ PIXEL cache[LRU_CACHE],
+ PIXEL pixel)
+{
+ int e;
+
+ e = LRU_CACHE - 1;
+ while (--e >= 0)
+ cache[e+1] = cache[e];
+ cache[0] = pixel;
+}
+
+static PIXEL
+use (
+ PIXEL cache[LRU_CACHE],
+ int e)
+{
+ PIXEL tmp;
+
+ tmp = cache[e];
+ if (e)
+ {
+ while (--e >= 0)
+ cache[e+1] = cache[e];
+ cache[0] = tmp;
+ }
+ return tmp;
+}
+
+static void
+WcpAnalyzeImageNLRU (
+ const char *buf,
+ int len,
+ int width,
+ int height,
+ int bytes)
+{
+ unsigned char *data = (unsigned char *) buf;
+ unsigned char byte;
+ int x, y;
+ int w;
+ int i;
+ int bytewidth;
+ int cache;
+ unsigned long run;
+ PIXEL lru[LRU_CACHE];
+ PIXEL pix;
+ const char *error = NULL;
+
+ y = 0;
+ bytewidth = width * bytes;
+ while (!error && height--)
+ {
+ x = 0;
+ if (Verbose > 2)
+ fprintf (stdout, "%s %9d %9d:", Leader, y, (char *) data - buf);
+ NextByte (byte);
+ if (Verbose > 2)
+ fprintf (stdout, " %2x", byte);
+ switch (byte) {
+ case 0xff:
+ for (i = 0; i < bytewidth; i++)
+ {
+ NextByte (byte);
+ }
+ break;
+ default:
+ init_cache (lru, bytes * 8);
+ w = width;
+ while (w)
+ {
+ NextByte (byte);
+ run = byte >> 4;
+ cache = byte & 0xf;
+ if (run == LRU_LONG)
+ {
+ NextByte (byte);
+ run = (int) byte + MAX_LRU_SHORT;
+ }
+ run++;
+ if (cache == LRU_MISS)
+ {
+ pix = 0;
+ for (i = 0; i < bytes; i++)
+ {
+ pix = pix << 8;
+ NextByte (byte);
+ pix |= byte;
+ }
+ push (lru, pix);
+ }
+ else
+ {
+ pix = use (lru, cache);
+ }
+ w -= run;
+ if (w < 0)
+ {
+ error = "bad run";
+ break;
+ }
+ x += run;
+ fprintf (stdout, " %3ld:%0*x", run, bytes * 2, pix);
+ }
+ break;
+ }
+ if (Verbose > 2)
+ fprintf (stdout, "\n");
+ y++;
+ }
+ if (error)
+ fprintf (stdout, "%s%20s: %d, %d %d\n", Leader, error,
+ x, y - 1, (char *) data - buf);
+}
+
+static void
+WcpAnalyzeImage (
+ const char *buf,
+ int len,
+ int depth,
+ int encoding,
+ int width,
+ int height)
+{
+ int bytes;
+
+ bytes = depth / 8;
+ switch (depth) {
+ case 1:
+ switch (encoding) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ WcpAnalyzeImage1RLL (buf, len, width, height);
+ return;
+ default:
+ break;
+ }
+ break;
+ case 4:
+ switch (encoding) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ default:
+ break;
+ }
+ break;
+ case 8:
+ case 16:
+ case 24:
+ switch (encoding) {
+ case 1:
+ case 2:
+ case 3:
+ WcpAnalyzeImageNRLL (buf, len, width, height, bytes);
+ return;
+ case 4:
+ WcpAnalyzeImageNLRU (buf, len, width, height, bytes);
+ return;
+ default:
+ break;
+ }
+ break;
+ }
+ fprintf (stdout, "%s%20s: ", Leader, "invalid");
+ fprintf (stdout, "encoding %d depth %d\n", encoding, depth);
+}
+
+void
+WcpPutImage (
+ FD fd,
+ const unsigned char *buf)
+{
+ int n;
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ n = (IShort(&buf[2]) - 7) * 4;
+ printreqlen(buf, fd, DVALUE2(7 + (n + p) / 4));
+ PrintField(buf, 4, 4, DRAWABLE, "drawable");
+ PrintField(buf, 8, 4, GCONTEXT, "gc");
+ if (Verbose > 2)
+ PrintValueRec (ILong(&buf[8]),
+ GC_function|
+ GC_plane_mask|
+ GC_foreground|
+ GC_background,
+ GC_BITMASK);
+ PrintField(buf, 12, 4, CARD32, "lut");
+ PrintField(buf, 16, 2, INT16, "dst-x");
+ PrintField(buf, 18, 2, INT16, "dst-y");
+ PrintField(buf, 20, 2, CARD16, "width");
+ PrintField(buf, 22, 2, CARD16, "height");
+ PrintField(buf, 24, 1, CARD8, "depth");
+ PrintField(buf, 25, 1, CARD8, "encoding");
+ PrintField(buf, 26, 1, CARD8, "left-pad");
+ WcpAnalyzeImage ((const char *) &buf[28], (long) n, buf[24], buf[25],
+ IShort(&buf[20]) + buf[26],
+ IShort(&buf[22]));
+ PrintBytes(&buf[28], (long)n, "data");
+}
+
+void
+WcpGetImage (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+ PrintField(buf, 4, 4, DRAWABLE, "drawable");
+ PrintField(buf, 8, 4, CARD32, "lut");
+ PrintField(buf, 12, 2, INT16, "x");
+ PrintField(buf, 14, 2, INT16, "y");
+ PrintField(buf, 16, 2, CARD16, "width");
+ PrintField(buf, 18, 2, CARD16, "height");
+ PrintField(buf, 20, 1, CARD8, "encoding");
+}
+
+void
+WcpGetImageReply (
+ FD fd,
+ const unsigned char *buf)
+{
+ long n;
+
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* WcpRequest reply */ ;
+ PrintField(RBf, 1, 1, WCPREPLY, WCPREPLYHEADER) /* WcpGetImage reply */;
+ if (Verbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4(n), "reply length");
+ PrintField(buf, 8, 4, CARD32, "visual");
+ n = ILong (&buf[4]) * 4;
+ PrintBytes (&buf[32], n, "data");
+}
+
+void
+WcpCreateColorCursor (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+WcpCreateLut (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+WcpFreeLut (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
+
+void
+WcpCopyArea (
+ FD fd,
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, REQUEST, REQUESTHEADER) /* WcpRequest */ ;
+ PrintField (buf, 1, 1, WCPREQUEST, WCPREQUESTHEADER) /* WcpSwitch */ ;
+ if (Verbose < 1)
+ return;
+ if (Verbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+
+ printreqlen(buf, fd, CONST2(2));
+}
diff --git a/printnas.c b/printnas.c
new file mode 100644
index 0000000..64d8dad
--- /dev/null
+++ b/printnas.c
@@ -0,0 +1,1012 @@
+/* ************************************************** *
+ * *
+ * Request, Reply, Event, Error Printing *
+ * *
+ * James Peterson, 1988 *
+ * (c) Copyright MCC, 1988 *
+ * *
+ * ************************************************** */
+
+#include "scope.h"
+#include "nas.h"
+
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+/*
+ In printing the contents of the fields of the X11 packets, some
+ fields are of obvious value, and others are of lesser value. To
+ control the amount of output, we generate our output according
+ to the level of Verbose-ness that was selected by the user.
+
+ NasVerbose = 0 == Headers only, time and request/reply/... names.
+
+ NasVerbose = 1 == Very useful content fields.
+
+ NasVerbose = 2 == Almost everything.
+
+ NasVerbose = 3 == Every single bit and byte.
+
+*/
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (NasVerbose > 1) PrintField(a,b,c,d,e)
+
+static void PrintFailedAudioSetUpReply (const unsigned char *buf);
+static void PrintSuccessfulAudioSetUpReply (const unsigned char *buf);
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+void
+PrintAudioSetUpMessage(
+ const unsigned char *buf)
+{
+ short n;
+ short d;
+
+ enterprocedure("PrintSetUpMessage");
+ if (NasVerbose < 1)
+ return;
+ SetIndentLevel(PRINTCLIENT);
+ PrintField(buf, 0, 1, BYTEMODE, "byte-order");
+ PrintField(buf, 2, 2, CARD16, "major-version");
+ PrintField(buf, 4, 2, CARD16, "minor-version");
+ printfield(buf, 6, 2, DVALUE2(n), "length of name");
+ n = IShort(&buf[6]);
+ printfield(buf, 8, 2, DVALUE2(d), "length of data");
+ d = IShort(&buf[8]);
+ PrintString8(&buf[12], (long)n, "authorization-protocol-name");
+ PrintString8(&buf[pad((long)(12+n))], (long)d, "authorization-protocol-data");
+}
+
+void
+PrintAudioSetUpReply(const unsigned char *buf)
+{
+ enterprocedure("PrintSetUpReply");
+ SetIndentLevel(PRINTSERVER);
+ if (IByte(&buf[0]))
+ PrintSuccessfulAudioSetUpReply(buf);
+ else
+ PrintFailedAudioSetUpReply(buf);
+}
+
+static void
+PrintFailedAudioSetUpReply(const unsigned char *buf)
+{
+ short n;
+
+ PrintField(buf, 0, 1, 0, "SetUp Failed");
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 1, 1, DVALUE1(n), "length of reason in bytes");
+ n = IByte(&buf[1]);
+ PrintField(buf, 2, 2, CARD16, "major-version");
+ PrintField(buf, 4, 2, CARD16, "minor-version");
+ printfield(buf, 6, 2, DVALUE2((n + p) / 4), "length of data");
+ PrintString8(&buf[8], (long)n, "reason");
+}
+
+static void
+PrintSuccessfulAudioSetUpReply(
+ const unsigned char *buf)
+{
+ short v;
+ short n;
+ short m;
+
+ if (NasVerbose < 1)
+ return;
+ PrintField(buf, 2, 2, CARD16, "protocol-major-version");
+ PrintField(buf, 4, 2, CARD16, "protocol-minor-version");
+ printfield(buf, 6, 2, DVALUE2(8 + 2*n + (v + p + m) / 4), "length of data");
+ PrintField(buf, 8, 4, CARD32, "release-number");
+ PrintField(buf, 12, 4, CARD32, "resource-id-base");
+ PrintField(buf, 16, 4, CARD32, "resource-id-mask");
+ PrintField(buf, 20, 2, CARD16, "min-sample-rate");
+ PrintField(buf, 22, 2, CARD16, "max-sample-rate");
+ printfield(buf, 24, 2, DVALUE2(v), "length of vendor");
+ v = IShort(&buf[24]);
+ printfield(buf, 26, 2, CARD16, "maximum-request-length");
+ printfield(buf, 28, 1, CARD8, "max-tracks");
+ m = IByte(&buf[28]);
+ printfield(buf, 29, 1, DVALUE1(n), "number of audio formats");
+ n = IByte(&buf[29]);
+ PrintField(buf, 30, 1, CARD8, "number of element-types");
+ PrintField(buf, 31, 1, CARD8, "number of wave-forms");
+ PrintField(buf, 32, 1, CARD8, "number of actions");
+ PrintField(buf, 33, 1, CARD8, "number of devices");
+ PrintField(buf, 34, 1, CARD8, "number of buckets");
+ PrintField(buf, 35, 1, CARD8, "number of radios");
+ PrintString8(&buf[36], (long)v, "vendor");
+}
+
+
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+/* Error Printing procedures */
+
+static void
+AudioRequestError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Request */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioValueError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Value */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, INT32, "bad value");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioMatchError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Match */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioAccessError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Access */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioAllocError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Alloc */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioIDChoiceError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* IDChoice */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, CARD32, "bad resource id");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioLengthError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Length */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+static void
+AudioImplementationError(
+ const unsigned char *buf)
+{
+ PrintField(buf, 1, 1, ERROR, ERRORHEADER) /* Implementation */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 8, 2, CARD16, "minor opcode");
+ PrintField(buf, 10, 1, CARD8, "major opcode");
+}
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+/* Event Printing procedures */
+
+void
+AudioElementNotify (
+ const unsigned char *buf)
+{
+ PrintField(buf, 0, 1, NASEVENT, EVENTHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 1, 1, CARD8, "detail");
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, TIMESTAMP, "time");
+ PrintField(buf, 8, 4, CARD32, "flow");
+ printfield(buf, 12, 2, CARD16, "element num");
+ printfield(buf, 14, 2, CARD16, "kind");
+ printfield(buf, 16, 2, CARD16, "prev state");
+ printfield(buf, 18, 2, CARD16, "cur state");
+ printfield(buf, 20, 2, CARD16, "reason");
+ printfield(buf, 24, 4, CARD32, "num bytes");
+}
+
+void
+AudioGrabNotify (
+ const unsigned char *buf)
+{
+}
+
+void
+AudioMonitorNotify (
+ const unsigned char *buf)
+{
+ PrintField(buf, 0, 1, NASEVENT, EVENTHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 1, 1, CARD8, "detail");
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ PrintField(buf, 4, 4, TIMESTAMP, "time");
+ PrintField(buf, 8, 4, CARD32, "flow");
+ printfield(buf, 12, 2, CARD16, "element num");
+ printfield(buf, 14, 1, CARD8, "format");
+ printfield(buf, 15, 1, CARD8, "num tracks");
+ printfield(buf, 16, 2, CARD16, "count");
+ printfield(buf, 18, 2, CARD16, "num fields");
+ PrintField(buf, 20, 4, CARD32, "data");
+ PrintField(buf, 24, 4, CARD32, "date1");
+ PrintField(buf, 28, 4, CARD32, "data2");
+}
+
+void
+AudioBucketNotify (
+ const unsigned char *buf)
+{
+}
+
+void
+AudioDeviceNotify (
+ const unsigned char *buf)
+{
+}
+
+/* ************************************************************ */
+/* */
+/* */
+/* ************************************************************ */
+
+/* Request and Reply Printing procedures */
+
+void
+UnknownAudioReply(
+ const unsigned char *buf)
+{
+ long n;
+
+ PrintField(RBf, 0, 1, NASREPLY, REPLYHEADER);
+ PrintField(buf, 1, 1, CARD8, "data");
+ printfield (buf, 2, 2, CARD16, "sequence number");
+ printfield (buf, 4, 4, DVALUE4(n), "reply length");
+ n = ILong (&buf[4]) + 6;
+ (void) PrintList (&buf[8], n, CARD32, "data");
+}
+
+void
+AudioListDevices (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER) /* ListDevices */;
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListDevicesReply(
+ const unsigned char *buf)
+{
+ long n;
+ PrintField(RBf, 0, 1, REPLY, REPLYHEADER) /* GetWindowAttributes */ ;
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, CARD32, "reply length");
+ printfield(buf, 8, 4, CARD32, "num devices");
+ n = ILong(&buf[8]);
+}
+
+static long
+AuString (
+ const unsigned char *buf)
+{
+ long n;
+
+ printfield(buf, 0, 1, CARD8, "type");
+ printfield(buf, 4, 4, CARD32, "length");
+ n = ILong(&buf[8]);
+ PrintString8(&buf[8], n, "string");
+ return 8 + pad(n);
+}
+
+static void
+AuDeviceAttributes (
+ const unsigned char *buf)
+{
+ int l;
+ printfield(buf, 0, 4, CARD32, "value mask");
+ printfield(buf, 4, 4, CARD32, "changable mask");
+ printfield(buf, 8, 4, CARD32, "id");
+ printfield(buf, 12, 1, CARD8, "kind");
+ printfield(buf, 13, 1, CARD8, "use");
+ printfield(buf, 14, 1, CARD8, "format");
+ printfield(buf, 15, 1, CARD8, "num tracks");
+ printfield(buf, 16, 4, CARD32, "access");
+ l = 20 + AuString(&buf[20]);
+}
+
+void
+AudioGetDeviceAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetDeviceAttributesReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+ AuDeviceAttributes (&buf[32]);
+}
+
+void
+AudioSetDeviceAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+ printfield(buf, 4, 4, CARD32, "device");
+ AuDeviceAttributes (&buf[8]);
+}
+
+void
+AudioCreateBucket (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioDestroyBucket (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListBuckets (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListBucketsReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioGetBucketAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetBucketAttributesReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetBucketAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioCreateRadio (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioDestroyRadio (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListRadios (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListRadiosReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioGetRadioAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetRadioAttributesReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetRadioAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioCreateFlow (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioDestroyFlow (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetFlowAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetFlowAttributesReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetFlowAttributes (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetElements (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetElementsReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetElements (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetElementStates (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioElementState (
+ const unsigned char *buf)
+{
+ printfield(buf, 0, 4, CARD32, "flow");
+ printfield(buf, 4, 1, CARD8, "element number");
+ printfield(buf, 5, 1, CARD8, "state");
+}
+
+void
+AudioGetElementStatesReply (
+ const unsigned char *buf)
+{
+ int n, i;
+ int o;
+
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+ n = ILong(&buf[8]);
+ o = 32;
+ for (i = 0; i < n; i++)
+ {
+ AudioElementState (buf+o);
+ o += 8;
+ }
+}
+
+void
+AudioSetElementStates (
+ const unsigned char *buf)
+{
+ int nstates, i;
+ int o;
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+ printfield(buf, 4, 4, CARD32, "number states");
+ nstates = ILong(&buf[4]);
+ o = 8;
+ for (i = 0; i < nstates; i++)
+ {
+ AudioElementState (buf+o);
+ o += 8;
+ }
+}
+
+void
+AudioGetElementParameters (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetElementParametersReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetElementParameters (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioWriteElement (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+ printfield(buf, 4, 4, CARD32, "flow");
+ printfield(buf, 8, 4, CARD32, "num bytes");
+ printfield(buf, 12, 1, CARD8, "state");
+}
+
+void
+AudioReadElement (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioReadElementReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioGrabComponent (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioUngrabComponent (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioSendEvent (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetAllowedUsers (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetAllowedUsersReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetAllowedUsers (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListExtensions (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioListExtensionsReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioQueryExtension (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioQueryExtensionReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioGetCloseDownMode (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetCloseDownModeReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioSetCloseDownMode (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioKillClient (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetServerTime (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
+
+void
+AudioGetServerTimeReply (
+ const unsigned char *buf)
+{
+ PrintField (RBf, 0, 1, NASREPLY, REPLYHEADER);
+ if (NasVerbose < 1)
+ return;
+ printfield(buf, 2, 2, CARD16, "sequence number");
+ printfield(buf, 4, 4, DVALUE4((n + p) / 4), "reply length");
+}
+
+void
+AudioNoOperation (
+ const unsigned char *buf)
+{
+ PrintField (buf, 0, 1, NASREQUEST, REQUESTHEADER);
+ if (NasVerbose < 1)
+ return;
+ if (NasVerbose > 1)
+ PrintField(SBf, 0, 4, CARD32, "sequence number");
+ printfield(buf, 2, 2, DVALUE2(8 + n), "request length");
+}
diff --git a/proto.h b/proto.h
index 397cb6b..ce30e56 100644
--- a/proto.h
+++ b/proto.h
@@ -1,266 +1,299 @@
#include "x11.h"
/* common.c */
-void enterprocedure(char *s);
-void warn(char *s);
-void panic(char *s);
-void *Malloc(long n);
-void Free(void *p);
-void SetSignalHandling(void);
-void SetUpConnectionSocket(int iport);
+extern void enterprocedure (char *s);
+extern void warn (char *s);
+extern void panic (char *s);
+extern void *Malloc (long n);
+extern void Free (void *p);
+extern void SetSignalHandling (void);
+extern void SetUpConnectionSocket (int iport, void (*connectionFunc) (int));
+
/* decode11.c */
-void InitReplyQ(void);
-void FlushReplyQ(FD fd);
-void KeepLastReplyExpected(void);
-void DecodeRequest(FD fd, unsigned char *buf, long n);
-void DecodeReply(FD fd, unsigned char *buf, long n);
-void DecodeError(FD fd, unsigned char *buf, long n);
-void DecodeEvent(FD fd, unsigned char *buf, long n);
+extern void InitReplyQ (void);
+extern void FlushReplyQ (FD fd);
+extern short CheckReplyTable (FD fd, short SequenceNumber, short *minorp);
+extern void ReplyExpected (FD fd, short Request);
+extern void ExtendedReplyExpected (FD fd, short Request, short RequestMinor);
+extern void KeepLastReplyExpected (void);
+
+extern void DecodeRequest (FD fd, const unsigned char *buf, long n);
+extern void DecodeReply (FD fd, const unsigned char *buf, long n);
+extern void DecodeError (FD fd, const unsigned char *buf, long n);
+extern void DecodeEvent (FD fd, const unsigned char *buf, long n);
+
/* print11.c */
-void PrintSetUpMessage(unsigned char *buf);
-void PrintSetUpReply(unsigned char *buf);
-void RequestError(unsigned char *buf);
-void ValueError(unsigned char *buf);
-void WindowError(unsigned char *buf);
-void PixmapError(unsigned char *buf);
-void AtomError(unsigned char *buf);
-void CursorError(unsigned char *buf);
-void FontError(unsigned char *buf);
-void MatchError(unsigned char *buf);
-void DrawableError(unsigned char *buf);
-void AccessError(unsigned char *buf);
-void AllocError(unsigned char *buf);
-void ColormapError(unsigned char *buf);
-void GContextError(unsigned char *buf);
-void IDChoiceError(unsigned char *buf);
-void NameError(unsigned char *buf);
-void LengthError(unsigned char *buf);
-void ImplementationError(unsigned char *buf);
-void KeyPressEvent(unsigned char *buf);
-void KeyReleaseEvent(unsigned char *buf);
-void ButtonPressEvent(unsigned char *buf);
-void ButtonReleaseEvent(unsigned char *buf);
-void MotionNotifyEvent(unsigned char *buf);
-void EnterNotifyEvent(unsigned char *buf);
-void LeaveNotifyEvent(unsigned char *buf);
-void FocusInEvent(unsigned char *buf);
-void FocusOutEvent(unsigned char *buf);
-void KeymapNotifyEvent(unsigned char *buf);
-void ExposeEvent(unsigned char *buf);
-void GraphicsExposureEvent(unsigned char *buf);
-void NoExposureEvent(unsigned char *buf);
-void VisibilityNotifyEvent(unsigned char *buf);
-void CreateNotifyEvent(unsigned char *buf);
-void DestroyNotifyEvent(unsigned char *buf);
-void UnmapNotifyEvent(unsigned char *buf);
-void MapNotifyEvent(unsigned char *buf);
-void MapRequestEvent(unsigned char *buf);
-void ReparentNotifyEvent(unsigned char *buf);
-void ConfigureNotifyEvent(unsigned char *buf);
-void ConfigureRequestEvent(unsigned char *buf);
-void GravityNotifyEvent(unsigned char *buf);
-void ResizeRequestEvent(unsigned char *buf);
-void CirculateNotifyEvent(unsigned char *buf);
-void CirculateRequestEvent(unsigned char *buf);
-void PropertyNotifyEvent(unsigned char *buf);
-void SelectionClearEvent(unsigned char *buf);
-void SelectionRequestEvent(unsigned char *buf);
-void SelectionNotifyEvent(unsigned char *buf);
-void ColormapNotifyEvent(unsigned char *buf);
-void ClientMessageEvent(unsigned char *buf);
-void MappingNotifyEvent(unsigned char *buf);
-void CreateWindow(unsigned char *buf);
-void ChangeWindowAttributes(unsigned char *buf);
-void GetWindowAttributes(unsigned char *buf);
-void GetWindowAttributesReply(unsigned char *buf);
-void DestroyWindow(unsigned char *buf);
-void DestroySubwindows(unsigned char *buf);
-void ChangeSaveSet(unsigned char *buf);
-void ReparentWindow(unsigned char *buf);
-void MapWindow(unsigned char *buf);
-void MapSubwindows(unsigned char *buf);
-void UnmapWindow(unsigned char *buf);
-void UnmapSubwindows(unsigned char *buf);
-void ConfigureWindow(unsigned char *buf);
-void CirculateWindow(unsigned char *buf);
-void GetGeometry(unsigned char *buf);
-void GetGeometryReply(unsigned char *buf);
-void QueryTree(unsigned char *buf);
-void QueryTreeReply(unsigned char *buf);
-void InternAtom(unsigned char *buf);
-void InternAtomReply(unsigned char *buf);
-void GetAtomName(unsigned char *buf);
-void GetAtomNameReply(unsigned char *buf);
-void ChangeProperty(unsigned char *buf);
-void DeleteProperty(unsigned char *buf);
-void GetProperty(unsigned char *buf);
-void GetPropertyReply(unsigned char *buf);
-void ListProperties(unsigned char *buf);
-void ListPropertiesReply(unsigned char *buf);
-void SetSelectionOwner(unsigned char *buf);
-void GetSelectionOwner(unsigned char *buf);
-void GetSelectionOwnerReply(unsigned char *buf);
-void ConvertSelection(unsigned char *buf);
-void SendEvent(unsigned char *buf);
-void GrabPointer(unsigned char *buf);
-void GrabPointerReply(unsigned char *buf);
-void UngrabPointer(unsigned char *buf);
-void GrabButton(unsigned char *buf);
-void UngrabButton(unsigned char *buf);
-void ChangeActivePointerGrab(unsigned char *buf);
-void GrabKeyboard(unsigned char *buf);
-void GrabKeyboardReply(unsigned char *buf);
-void UngrabKeyboard(unsigned char *buf);
-void GrabKey(unsigned char *buf);
-void UngrabKey(unsigned char *buf);
-void AllowEvents(unsigned char *buf);
-void GrabServer(unsigned char *buf);
-void UngrabServer(unsigned char *buf);
-void QueryPointer(unsigned char *buf);
-void QueryPointerReply(unsigned char *buf);
-void GetMotionEvents(unsigned char *buf);
-void GetMotionEventsReply(unsigned char *buf);
-void TranslateCoordinates(unsigned char *buf);
-void TranslateCoordinatesReply(unsigned char *buf);
-void WarpPointer(unsigned char *buf);
-void SetInputFocus(unsigned char *buf);
-void GetInputFocus(unsigned char *buf);
-void GetInputFocusReply(unsigned char *buf);
-void QueryKeymap(unsigned char *buf);
-void QueryKeymapReply(unsigned char *buf);
-void OpenFont(unsigned char *buf);
-void CloseFont(unsigned char *buf);
-void QueryFont(unsigned char *buf);
-void QueryFontReply(unsigned char *buf);
-void QueryTextExtents(unsigned char *buf);
-void QueryTextExtentsReply(unsigned char *buf);
-void ListFonts(unsigned char *buf);
-void ListFontsReply(unsigned char *buf);
-void ListFontsWithInfo(unsigned char *buf);
-void ListFontsWithInfoReply(unsigned char *buf);
-void SetFontPath(unsigned char *buf);
-void GetFontPath(unsigned char *buf);
-void GetFontPathReply(unsigned char *buf);
-void CreatePixmap(unsigned char *buf);
-void FreePixmap(unsigned char *buf);
-void CreateGC(unsigned char *buf);
-void ChangeGC(unsigned char *buf);
-void CopyGC(unsigned char *buf);
-void SetDashes(unsigned char *buf);
-void SetClipRectangles(unsigned char *buf);
-void FreeGC(unsigned char *buf);
-void ClearArea(unsigned char *buf);
-void CopyArea(unsigned char *buf);
-void CopyPlane(unsigned char *buf);
-void PolyPoint(unsigned char *buf);
-void PolyLine(unsigned char *buf);
-void PolySegment(unsigned char *buf);
-void PolyRectangle(unsigned char *buf);
-void PolyArc(unsigned char *buf);
-void FillPoly(unsigned char *buf);
-void PolyFillRectangle(unsigned char *buf);
-void PolyFillArc(unsigned char *buf);
-void PutImage(unsigned char *buf);
-void GetImage(unsigned char *buf);
-void GetImageReply(unsigned char *buf);
-void PolyText8(unsigned char *buf);
-void PolyText16(unsigned char *buf);
-void ImageText8(unsigned char *buf);
-void ImageText16(unsigned char *buf);
-void CreateColormap(unsigned char *buf);
-void FreeColormap(unsigned char *buf);
-void CopyColormapAndFree(unsigned char *buf);
-void InstallColormap(unsigned char *buf);
-void UninstallColormap(unsigned char *buf);
-void ListInstalledColormaps(unsigned char *buf);
-void ListInstalledColormapsReply(unsigned char *buf);
-void AllocColor(unsigned char *buf);
-void AllocColorReply(unsigned char *buf);
-void AllocNamedColor(unsigned char *buf);
-void AllocNamedColorReply(unsigned char *buf);
-void AllocColorCells(unsigned char *buf);
-void AllocColorCellsReply(unsigned char *buf);
-void AllocColorPlanes(unsigned char *buf);
-void AllocColorPlanesReply(unsigned char *buf);
-void FreeColors(unsigned char *buf);
-void StoreColors(unsigned char *buf);
-void StoreNamedColor(unsigned char *buf);
-void QueryColors(unsigned char *buf);
-void QueryColorsReply(unsigned char *buf);
-void LookupColor(unsigned char *buf);
-void LookupColorReply(unsigned char *buf);
-void CreateCursor(unsigned char *buf);
-void CreateGlyphCursor(unsigned char *buf);
-void FreeCursor(unsigned char *buf);
-void RecolorCursor(unsigned char *buf);
-void QueryBestSize(unsigned char *buf);
-void QueryBestSizeReply(unsigned char *buf);
-void QueryExtension(unsigned char *buf);
-void QueryExtensionReply(unsigned char *buf);
-void ListExtensions(unsigned char *buf);
-void ListExtensionsReply(unsigned char *buf);
-void ChangeKeyboardMapping(unsigned char *buf);
-void GetKeyboardMapping(unsigned char *buf);
-void GetKeyboardMappingReply(unsigned char *buf);
-void ChangeKeyboardControl(unsigned char *buf);
-void GetKeyboardControl(unsigned char *buf);
-void GetKeyboardControlReply(unsigned char *buf);
-void Bell(unsigned char *buf);
-void ChangePointerControl(unsigned char *buf);
-void GetPointerControl(unsigned char *buf);
-void GetPointerControlReply(unsigned char *buf);
-void SetScreenSaver(unsigned char *buf);
-void GetScreenSaver(unsigned char *buf);
-void GetScreenSaverReply(unsigned char *buf);
-void ChangeHosts(unsigned char *buf);
-void ListHosts(unsigned char *buf);
-void ListHostsReply(unsigned char *buf);
-void SetAccessControl(unsigned char *buf);
-void SetCloseDownMode(unsigned char *buf);
-void KillClient(unsigned char *buf);
-void RotateProperties(unsigned char *buf);
-void ForceScreenSaver(unsigned char *buf);
-void SetPointerMapping(unsigned char *buf);
-void SetPointerMappingReply(unsigned char *buf);
-void GetPointerMapping(unsigned char *buf);
-void GetPointerMappingReply(unsigned char *buf);
-void SetModifierMapping(unsigned char *buf);
-void SetModifierMappingReply(unsigned char *buf);
-void GetModifierMapping(unsigned char *buf);
-void GetModifierMappingReply(unsigned char *buf);
-void NoOperation(unsigned char *buf);
+extern void PrintSetUpMessage (const unsigned char *buf);
+extern void PrintSetUpReply (const unsigned char *buf);
+
+extern void RequestError (const unsigned char *buf);
+extern void ValueError (const unsigned char *buf);
+extern void WindowError (const unsigned char *buf);
+extern void PixmapError (const unsigned char *buf);
+extern void AtomError (const unsigned char *buf);
+extern void CursorError (const unsigned char *buf);
+extern void FontError (const unsigned char *buf);
+extern void MatchError (const unsigned char *buf);
+extern void DrawableError (const unsigned char *buf);
+extern void AccessError (const unsigned char *buf);
+extern void AllocError (const unsigned char *buf);
+extern void ColormapError (const unsigned char *buf);
+extern void GContextError (const unsigned char *buf);
+extern void IDChoiceError (const unsigned char *buf);
+extern void NameError (const unsigned char *buf);
+extern void LengthError (const unsigned char *buf);
+extern void ImplementationError (const unsigned char *buf);
+
+extern void KeyPressEvent (const unsigned char *buf);
+extern void KeyReleaseEvent (const unsigned char *buf);
+extern void ButtonPressEvent (const unsigned char *buf);
+extern void ButtonReleaseEvent (const unsigned char *buf);
+extern void MotionNotifyEvent (const unsigned char *buf);
+extern void EnterNotifyEvent (const unsigned char *buf);
+extern void LeaveNotifyEvent (const unsigned char *buf);
+extern void FocusInEvent (const unsigned char *buf);
+extern void FocusOutEvent (const unsigned char *buf);
+extern void KeymapNotifyEvent (const unsigned char *buf);
+extern void ExposeEvent (const unsigned char *buf);
+extern void GraphicsExposureEvent (const unsigned char *buf);
+extern void NoExposureEvent (const unsigned char *buf);
+extern void VisibilityNotifyEvent (const unsigned char *buf);
+extern void CreateNotifyEvent (const unsigned char *buf);
+extern void DestroyNotifyEvent (const unsigned char *buf);
+extern void UnmapNotifyEvent (const unsigned char *buf);
+extern void MapNotifyEvent (const unsigned char *buf);
+extern void MapRequestEvent (const unsigned char *buf);
+extern void ReparentNotifyEvent (const unsigned char *buf);
+extern void ConfigureNotifyEvent (const unsigned char *buf);
+extern void ConfigureRequestEvent (const unsigned char *buf);
+extern void GravityNotifyEvent (const unsigned char *buf);
+extern void ResizeRequestEvent (const unsigned char *buf);
+extern void CirculateNotifyEvent (const unsigned char *buf);
+extern void CirculateRequestEvent (const unsigned char *buf);
+extern void PropertyNotifyEvent (const unsigned char *buf);
+extern void SelectionClearEvent (const unsigned char *buf);
+extern void SelectionRequestEvent (const unsigned char *buf);
+extern void SelectionNotifyEvent (const unsigned char *buf);
+extern void ColormapNotifyEvent (const unsigned char *buf);
+extern void ClientMessageEvent (const unsigned char *buf);
+extern void MappingNotifyEvent (const unsigned char *buf);
+
+extern void ExtendedRequest (int fd, const unsigned char *buf);
+extern void UnknownReply (const unsigned char *buf);
+
+extern void CreateWindow (FD fd, const unsigned char *buf);
+extern void ChangeWindowAttributes (FD fd, const unsigned char *buf);
+extern void GetWindowAttributes (FD fd, const unsigned char *buf);
+extern void GetWindowAttributesReply (const unsigned char *buf);
+extern void DestroyWindow (FD fd, const unsigned char *buf);
+extern void DestroySubwindows (FD fd, const unsigned char *buf);
+extern void ChangeSaveSet (FD fd, const unsigned char *buf);
+extern void ReparentWindow (FD fd, const unsigned char *buf);
+extern void MapWindow (FD fd, const unsigned char *buf);
+extern void MapSubwindows (FD fd, const unsigned char *buf);
+extern void UnmapWindow (FD fd, const unsigned char *buf);
+extern void UnmapSubwindows (FD fd, const unsigned char *buf);
+extern void ConfigureWindow (FD fd, const unsigned char *buf);
+extern void CirculateWindow (FD fd, const unsigned char *buf);
+extern void GetGeometry (FD fd, const unsigned char *buf);
+extern void GetGeometryReply (const unsigned char *buf);
+extern void QueryTree (FD fd, const unsigned char *buf);
+extern void QueryTreeReply (const unsigned char *buf);
+extern void InternAtom (FD fd, const unsigned char *buf);
+extern void InternAtomReply (const unsigned char *buf);
+extern void GetAtomName (FD fd, const unsigned char *buf);
+extern void GetAtomNameReply (const unsigned char *buf);
+extern void ChangeProperty (FD fd, const unsigned char *buf);
+extern void DeleteProperty (FD fd, const unsigned char *buf);
+extern void GetProperty (FD fd, const unsigned char *buf);
+extern void GetPropertyReply (const unsigned char *buf);
+extern void ListProperties (FD fd, const unsigned char *buf);
+extern void ListPropertiesReply (const unsigned char *buf);
+extern void SetSelectionOwner (FD fd, const unsigned char *buf);
+extern void GetSelectionOwner (FD fd, const unsigned char *buf);
+extern void GetSelectionOwnerReply (const unsigned char *buf);
+extern void ConvertSelection (FD fd, const unsigned char *buf);
+extern void SendEvent (FD fd, const unsigned char *buf);
+extern void GrabPointer (FD fd, const unsigned char *buf);
+extern void GrabPointerReply (const unsigned char *buf);
+extern void UngrabPointer (FD fd, const unsigned char *buf);
+extern void GrabButton (FD fd, const unsigned char *buf);
+extern void UngrabButton (FD fd, const unsigned char *buf);
+extern void ChangeActivePointerGrab (FD fd, const unsigned char *buf);
+extern void GrabKeyboard (FD fd, const unsigned char *buf);
+extern void GrabKeyboardReply (const unsigned char *buf);
+extern void UngrabKeyboard (FD fd, const unsigned char *buf);
+extern void GrabKey (FD fd, const unsigned char *buf);
+extern void UngrabKey (FD fd, const unsigned char *buf);
+extern void AllowEvents (FD fd, const unsigned char *buf);
+extern void GrabServer (FD fd, const unsigned char *buf);
+extern void UngrabServer (FD fd, const unsigned char *buf);
+extern void QueryPointer (FD fd, const unsigned char *buf);
+extern void QueryPointerReply (const unsigned char *buf);
+extern void GetMotionEvents (FD fd, const unsigned char *buf);
+extern void GetMotionEventsReply (const unsigned char *buf);
+extern void TranslateCoordinates (FD fd, const unsigned char *buf);
+extern void TranslateCoordinatesReply (const unsigned char *buf);
+extern void WarpPointer (FD fd, const unsigned char *buf);
+extern void SetInputFocus (FD fd, const unsigned char *buf);
+extern void GetInputFocus (FD fd, const unsigned char *buf);
+extern void GetInputFocusReply (const unsigned char *buf);
+extern void QueryKeymap (FD fd, const unsigned char *buf);
+extern void QueryKeymapReply (const unsigned char *buf);
+extern void OpenFont (FD fd, const unsigned char *buf);
+extern void CloseFont (FD fd, const unsigned char *buf);
+extern void QueryFont (FD fd, const unsigned char *buf);
+extern void QueryFontReply (const unsigned char *buf);
+extern void QueryTextExtents (FD fd, const unsigned char *buf);
+extern void QueryTextExtentsReply (const unsigned char *buf);
+extern void ListFonts (FD fd, const unsigned char *buf);
+extern void ListFontsReply (const unsigned char *buf);
+extern void ListFontsWithInfo (FD fd, const unsigned char *buf);
+extern void ListFontsWithInfoReply (const unsigned char *buf);
+extern void SetFontPath (FD fd, const unsigned char *buf);
+extern void GetFontPath (FD fd, const unsigned char *buf);
+extern void GetFontPathReply (const unsigned char *buf);
+extern void CreatePixmap (FD fd, const unsigned char *buf);
+extern void FreePixmap (FD fd, const unsigned char *buf);
+extern void CreateGC (FD fd, const unsigned char *buf);
+extern void ChangeGC (FD fd, const unsigned char *buf);
+extern void CopyGC (FD fd, const unsigned char *buf);
+extern void SetDashes (FD fd, const unsigned char *buf);
+extern void SetClipRectangles (FD fd, const unsigned char *buf);
+extern void FreeGC (FD fd, const unsigned char *buf);
+extern void ClearArea (FD fd, const unsigned char *buf);
+extern void CopyArea (FD fd, const unsigned char *buf);
+extern void CopyPlane (FD fd, const unsigned char *buf);
+extern void PolyPoint (FD fd, const unsigned char *buf);
+extern void PolyLine (FD fd, const unsigned char *buf);
+extern void PolySegment (FD fd, const unsigned char *buf);
+extern void PolyRectangle (FD fd, const unsigned char *buf);
+extern void PolyArc (FD fd, const unsigned char *buf);
+extern void FillPoly (FD fd, const unsigned char *buf);
+extern void PolyFillRectangle (FD fd, const unsigned char *buf);
+extern void PolyFillArc (FD fd, const unsigned char *buf);
+extern void PutImage (FD fd, const unsigned char *buf);
+extern void GetImage (FD fd, const unsigned char *buf);
+extern void GetImageReply (const unsigned char *buf);
+extern void PolyText8 (FD fd, const unsigned char *buf);
+extern void PolyText16 (FD fd, const unsigned char *buf);
+extern void ImageText8 (FD fd, const unsigned char *buf);
+extern void ImageText16 (FD fd, const unsigned char *buf);
+extern void CreateColormap (FD fd, const unsigned char *buf);
+extern void FreeColormap (FD fd, const unsigned char *buf);
+extern void CopyColormapAndFree (FD fd, const unsigned char *buf);
+extern void InstallColormap (FD fd, const unsigned char *buf);
+extern void UninstallColormap (FD fd, const unsigned char *buf);
+extern void ListInstalledColormaps (FD fd, const unsigned char *buf);
+extern void ListInstalledColormapsReply (const unsigned char *buf);
+extern void AllocColor (FD fd, const unsigned char *buf);
+extern void AllocColorReply (const unsigned char *buf);
+extern void AllocNamedColor (FD fd, const unsigned char *buf);
+extern void AllocNamedColorReply (const unsigned char *buf);
+extern void AllocColorCells (FD fd, const unsigned char *buf);
+extern void AllocColorCellsReply (const unsigned char *buf);
+extern void AllocColorPlanes (FD fd, const unsigned char *buf);
+extern void AllocColorPlanesReply (const unsigned char *buf);
+extern void FreeColors (FD fd, const unsigned char *buf);
+extern void StoreColors (FD fd, const unsigned char *buf);
+extern void StoreNamedColor (FD fd, const unsigned char *buf);
+extern void QueryColors (FD fd, const unsigned char *buf);
+extern void QueryColorsReply (const unsigned char *buf);
+extern void LookupColor (FD fd, const unsigned char *buf);
+extern void LookupColorReply (const unsigned char *buf);
+extern void CreateCursor (FD fd, const unsigned char *buf);
+extern void CreateGlyphCursor (FD fd, const unsigned char *buf);
+extern void FreeCursor (FD fd, const unsigned char *buf);
+extern void RecolorCursor (FD fd, const unsigned char *buf);
+extern void QueryBestSize (FD fd, const unsigned char *buf);
+extern void QueryBestSizeReply (const unsigned char *buf);
+extern void QueryExtension (FD fd, const unsigned char *buf);
+extern void QueryExtensionReply (const unsigned char *buf);
+extern void ListExtensions (FD fd, const unsigned char *buf);
+extern void ListExtensionsReply (const unsigned char *buf);
+extern void ChangeKeyboardMapping (FD fd, const unsigned char *buf);
+extern void GetKeyboardMapping (FD fd, const unsigned char *buf);
+extern void GetKeyboardMappingReply (const unsigned char *buf);
+extern void ChangeKeyboardControl (FD fd, const unsigned char *buf);
+extern void GetKeyboardControl (FD fd, const unsigned char *buf);
+extern void GetKeyboardControlReply (const unsigned char *buf);
+extern void Bell (FD fd, const unsigned char *buf);
+extern void ChangePointerControl (FD fd, const unsigned char *buf);
+extern void GetPointerControl (FD fd, const unsigned char *buf);
+extern void GetPointerControlReply (const unsigned char *buf);
+extern void SetScreenSaver (FD fd, const unsigned char *buf);
+extern void GetScreenSaver (FD fd, const unsigned char *buf);
+extern void GetScreenSaverReply (const unsigned char *buf);
+extern void ChangeHosts (FD fd, const unsigned char *buf);
+extern void ListHosts (FD fd, const unsigned char *buf);
+extern void ListHostsReply (const unsigned char *buf);
+extern void SetAccessControl (FD fd, const unsigned char *buf);
+extern void SetCloseDownMode (FD fd, const unsigned char *buf);
+extern void KillClient (FD fd, const unsigned char *buf);
+extern void RotateProperties (FD fd, const unsigned char *buf);
+extern void ForceScreenSaver (FD fd, const unsigned char *buf);
+extern void SetPointerMapping (FD fd, const unsigned char *buf);
+extern void SetPointerMappingReply (const unsigned char *buf);
+extern void GetPointerMapping (FD fd, const unsigned char *buf);
+extern void GetPointerMappingReply (const unsigned char *buf);
+extern void SetModifierMapping (FD fd, const unsigned char *buf);
+extern void SetModifierMappingReply (const unsigned char *buf);
+extern void GetModifierMapping (FD fd, const unsigned char *buf);
+extern void GetModifierMappingReply (const unsigned char *buf);
+extern void NoOperation (FD fd, const unsigned char *buf);
+
/* prtype.c */
-void SetIndentLevel(int which);
-void DumpItem(char *name, FD fd, unsigned char *buf, long n);
-void PrintField(unsigned char *buf, int start, int length, int FieldType, char *name);
-long PrintList(unsigned char *buf, long number, int ListType, char *name);
-long PrintListSTR(unsigned char *buf, long number, char *name);
-int PrintBytes(unsigned char buf[], long number, char *name);
-int PrintString8(unsigned char buf[], int number, char *name);
-int PrintString16(unsigned char buf[], int number, char *name);
-void PrintValues(unsigned char *control, int clength, int ctype, unsigned char *values, char *name);
-int PrintTextList8(unsigned char *buf, int length, char *name);
-int PrintTextList16(unsigned char *buf, int length, char *name);
+extern void SetIndentLevel (short which);
+extern void DumpHexBuffer (const unsigned char *buf, long n);
+extern void DumpItem (const char *name, FD fd,
+ const unsigned char *buf, long n);
+extern void PrintField (const unsigned char *buf, short start, short length,
+ short FieldType, const char *name);
+extern int PrintBytes (const unsigned char *buf, long number,
+ const char *name);
+extern void PrintValues (const unsigned char *control, int clength, int ctype,
+ const unsigned char *values, const char *name);
+extern void PrintTextList8 (const unsigned char *buf, int length,
+ const char *name);
+extern void PrintTextList16 (const unsigned char *buf, int length,
+ const char *name);
+
/* scope.c */
-void TimerExpired(void);
-FD FDPair(FD fd);
-FD ClientHalf(FD fd);
-FD ServerHalf(FD fd);
-char *ClientName(FD fd);
-void NewConnection(FD fd);
+extern void TestBreakPoints (const unsigned char *buf, long n);
+extern void TimerExpired (void);
+extern void SetUpPair (FD client, FD server);
+extern FD FDPair (FD fd);
+extern FD ClientHalf (FD fd);
+extern FD ServerHalf (FD fd);
+extern char *ClientName (FD fd);
+extern int ClientNumber (FD fd);
+extern void NewConnection (FD fd);
+extern void FlushFD (FD fd);
+extern short GetServerport (void);
+extern void ReadCommands (void);
+
/* server.c */
-void ReportFromClient(FD fd, unsigned char *buf, long n);
-void ReportFromServer(FD fd, unsigned char *buf, long n);
-void PrintTime(void);
-long pad(long n);
-unsigned long ILong(unsigned char buf[]);
-unsigned short IShort(unsigned char buf[]);
-unsigned short IByte(unsigned char buf[]);
-short IBool(unsigned char buf[]);
-void StartClientConnection(FD fd);
-void StopClientConnection(FD fd);
-void StartServerConnection(FD fd);
-void StopServerConnection(FD fd);
-/* table11.c */
-void InitializeX11(void);
+extern FD ConnectToServer (Boolean report);
+extern void ProcessBuffer (FD fd, const unsigned char *buf, long n);
+extern void ReportFromClient (FD fd, const unsigned char *buf, long n);
+extern void ReportFromServer (FD fd, const unsigned char *buf, long n);
+extern void PrintTime (void);
+extern void SetBufLimit (FD fd);
+extern void ClearBufLimit (FD fd);
+extern void StartClientConnection (FD fd);
+extern void StopClientConnection (FD fd);
+extern void StartServerConnection (FD fd);
+extern void StopServerConnection (FD fd);
+extern long StartSetUpMessage (FD fd, const unsigned char *buf, long n);
+extern long StartSetUpReply (FD fd, const unsigned char *buf, long n);
+
+extern long GetXRequestFromName (const char *name);
+/* table11.c */
+extern void InitializeX11 (void);
+extern TYPE DefineType (short typeid, short class, const char *name,
+ int (*printproc)(const unsigned char *));
+extern void DefineEValue (TYPE type, long value, const char *name);
+extern void DefineValues (TYPE type, long value, short length,
+ short ctype, const char *name);
+extern long GetEValue (short typeid, const char *name);
diff --git a/prtype.c b/prtype.c
index 4bcfb8b..6be200d 100644
--- a/prtype.c
+++ b/prtype.c
@@ -55,8 +55,6 @@
#include "scope.h"
#include "x11.h"
-static void DumpHexBuffer(unsigned char *buf, long n);
-
/*
For each of the types we need a way to print that type.
Types are of varieties:
@@ -76,8 +74,8 @@ static void DumpHexBuffer(unsigned char *buf, long n);
/* print representation of a character for debugging */
-static char *printrep (c)
- unsigned short c;
+static char *
+printrep (unsigned short c)
{
static char pr[8];
@@ -132,12 +130,12 @@ static char *printrep (c)
*/
#define MaxIndent 10
-static char Leader[MaxIndent + 1];
+char Leader[MaxIndent + 1];
static short CurrentLevel = 0;
void
-SetIndentLevel(which)
- short which;
+SetIndentLevel (
+ short which)
{
short i;
@@ -157,13 +155,14 @@ SetIndentLevel(which)
}
static void
-ModifyIndentLevel(amount)
- short amount;
+ModifyIndentLevel (
+ short amount)
{
SetIndentLevel(CurrentLevel + amount);
}
-static short SizeofLeader ()
+static short
+SizeofLeader (void)
{
return (CurrentLevel * 8);
}
@@ -176,11 +175,11 @@ static short SizeofLeader ()
/* if we want verbose enough output, we will dump the buffer in hex */
void
-DumpItem(name, fd, buf, n)
- char *name;
- FD fd;
- unsigned char *buf;
- long n;
+DumpItem (
+ const char *name,
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
if (n == 0)
return;
@@ -197,64 +196,69 @@ DumpItem(name, fd, buf, n)
/* ************************************************************ */
int
-PrintINT8(unsigned char *buf)
+PrintINT8(const unsigned char *buf)
{
/* print a INT8 -- 8-bit signed integer */
short n = IByte (buf);
if (n > 127)
n = 256 - n;
- return fprintf(stdout, "%d", n);
+ fprintf(stdout, "%d", n);
+ return 1;
}
int
-PrintINT16(unsigned char *buf)
+PrintINT16(const unsigned char *buf)
{
/* print a INT16 -- 16-bit signed integer */
long n = IShort (buf);
if (n > 32767)
n = 65536 - n;
- return fprintf(stdout, "%d", n);
+ fprintf(stdout, "%ld", n);
+ return 2;
}
int
-PrintINT32(unsigned char *buf)
+PrintINT32(const unsigned char *buf)
{
/* print a INT32 -- 32-bit signed integer */
long n = ILong (buf);
- return fprintf(stdout, "%d", n);
+ fprintf(stdout, "%ld", n);
+ return 4;
}
/* ************************************************************ */
int
-PrintCARD8(unsigned char *buf)
+PrintCARD8(const unsigned char *buf)
{
/* print a CARD8 -- 8-bit unsigned integer */
unsigned short n = IByte (buf);
- return fprintf(stdout, "%02x", (unsigned)(n & 0xff));
+ fprintf(stdout, "%02x", (unsigned)(n & 0xff));
+ return 1;
}
int
-PrintCARD16(unsigned char *buf)
+PrintCARD16(const unsigned char *buf)
{
/* print a CARD16 -- 16-bit unsigned integer */
unsigned long n = IShort (buf);
- return fprintf(stdout, "%04x", (unsigned)(n & 0xffff));
+ fprintf(stdout, "%04x", (unsigned)(n & 0xffff));
+ return 1;
}
int
-PrintCARD32(unsigned char *buf)
+PrintCARD32(const unsigned char *buf)
{
/* print a CARD32 -- 32-bit unsigned integer */
unsigned long n = ILong (buf);
- fprintf(stdout, "%08x", n);
+ fprintf(stdout, "%08lx", n);
return(4);
}
/* ************************************************************ */
int
-PrintBYTE(unsigned char *buf)
+PrintBYTE(const unsigned char *buf)
{
/* print a BYTE -- 8-bit value */
short n = IByte (buf);
@@ -264,7 +268,7 @@ PrintBYTE(unsigned char *buf)
int
-PrintCHAR8(unsigned char *buf)
+PrintCHAR8(const unsigned char *buf)
{
/* print a CHAR8 -- 8-bit character */
unsigned short n = IByte (buf);
@@ -274,16 +278,16 @@ PrintCHAR8(unsigned char *buf)
int
-PrintSTRING16(unsigned char *buf)
+PrintSTRING16(const unsigned char *buf)
{
- /* print a CHAR16 -- 16-bit character */
- unsigned short n = IShort (buf);
+ /* print a CHAR2B -- 16-bit character which is never byte-swapped */
+ unsigned short n = IChar2B (buf);
fprintf(stdout, "%s", printrep(n));
- return(1);
+ return 2 + n;
}
int
-PrintSTR(unsigned char *buf)
+PrintSTR(const unsigned char *buf)
{
/* STR have the length (1 byte) then a string of CHAR8 */
short n;
@@ -298,158 +302,169 @@ PrintSTR(unsigned char *buf)
/* ************************************************************ */
int
-PrintWINDOW(unsigned char *buf)
+PrintWINDOW(const unsigned char *buf)
{
/* print a WINDOW -- CARD32 plus 0 = None */
long n = ILong (buf);
if (n == 0)
fprintf(stdout, "None");
else
- fprintf(stdout, "WIN %08x", n);
+ fprintf(stdout, "WIN %08lx", n);
return(4);
}
int
-PrintWINDOWD(unsigned char *buf)
+PrintWINDOWD(const unsigned char *buf)
{
/* print a WINDOWD -- CARD32 plus 0 = PointerWindow, 1 = InputFocus */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "PointerWindow");
+ fprintf(stdout, "PointerWindow");
else if (n == 1)
- return fprintf(stdout, "InputFocus");
+ fprintf(stdout, "InputFocus");
else
- return PrintWINDOW(buf);
+ (void)PrintWINDOW(buf);
+ return 4;
}
int
-PrintWINDOWNR(unsigned char *buf)
+PrintWINDOWNR(const unsigned char *buf)
{
/* print a WINDOWNR -- CARD32 plus 0 = None, 1 = PointerRoot */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "None");
+ fprintf(stdout, "None");
else if (n == 1)
- return fprintf(stdout, "PointerRoot");
+ fprintf(stdout, "PointerRoot");
else
- return PrintWINDOW(buf);
+ (void)PrintWINDOW(buf);
+ return 4;
}
int
-PrintPIXMAP(unsigned char *buf)
+PrintPIXMAP(const unsigned char *buf)
{
/* print a PIXMAP -- CARD32 plus 0 = None */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "None");
+ fprintf(stdout, "None");
else
- return fprintf(stdout, "PXM %08x", n);
+ fprintf(stdout, "PXM %08lx", n);
+ return 4;
}
int
-PrintPIXMAPNPR(unsigned char *buf)
+PrintPIXMAPNPR(const unsigned char *buf)
{
/* print a PIXMAPNPR -- CARD32 plus 0 = None, 1 = ParentRelative */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "None");
+ fprintf(stdout, "None");
else if (n == 1)
- return fprintf(stdout, "ParentRelative");
+ fprintf(stdout, "ParentRelative");
else
- return PrintPIXMAP(buf);
+ PrintPIXMAP(buf);
+ return 4;
}
int
-PrintPIXMAPC(unsigned char *buf)
+PrintPIXMAPC(const unsigned char *buf)
{
/* print a PIXMAPC -- CARD32 plus 0 = CopyFromParent */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "CopyFromParent");
+ fprintf(stdout, "CopyFromParent");
else
- return PrintPIXMAP(buf);
+ PrintPIXMAP(buf);
+ return 4;
}
int
-PrintCURSOR(unsigned char *buf)
+PrintCURSOR(const unsigned char *buf)
{
/* print a CURSOR -- CARD32 plus 0 = None */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "None");
+ fprintf(stdout, "None");
else
- return fprintf(stdout, "CUR %08x", n);
+ fprintf(stdout, "CUR %08lx", n);
+ return 4;
}
int
-PrintFONT(unsigned char *buf)
+PrintFONT(const unsigned char *buf)
{
/* print a FONT -- CARD32 plus 0 = None */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "None");
+ fprintf(stdout, "None");
else
- return fprintf(stdout, "FNT %08x", n);
+ fprintf(stdout, "FNT %08lx", n);
+ return 4;
}
int
-PrintGCONTEXT(unsigned char *buf)
+PrintGCONTEXT(const unsigned char *buf)
{
/* print a GCONTEXT -- CARD32 */
long n = ILong (buf);
- return fprintf(stdout, "GXC %08x", n);
+ fprintf(stdout, "GXC %08lx", n);
+ return 4;
}
int
-PrintCOLORMAP(unsigned char *buf)
+PrintCOLORMAP(const unsigned char *buf)
{
/* print a COLORMAP -- CARD32 plus 0 = None */
long n = ILong (buf);
if (n == 0)
fprintf(stdout, "None");
else
- fprintf(stdout, "CMP %08x", n);
+ fprintf(stdout, "CMP %08lx", n);
return(4);
}
int
-PrintCOLORMAPC(unsigned char *buf)
+PrintCOLORMAPC(const unsigned char *buf)
{
/* print a COLORMAPC -- CARD32 plus 0 = CopyFromParent */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "CopyFromParent");
+ fprintf(stdout, "CopyFromParent");
else
- return PrintCOLORMAP(buf);
+ (void)PrintCOLORMAP(buf);
+ return 4;
}
int
-PrintDRAWABLE(unsigned char *buf)
+PrintDRAWABLE(const unsigned char *buf)
{
/* print a DRAWABLE -- CARD32 */
long n = ILong (buf);
- return fprintf(stdout, "DWB %08x", n);
+ fprintf(stdout, "DWB %08lx", n);
+ return 4;
}
int
-PrintFONTABLE(unsigned char *buf)
+PrintFONTABLE(const unsigned char *buf)
{
/* print a FONTABLE -- CARD32 */
long n = ILong (buf);
- return fprintf(stdout, "FTB %08x", n);
+ fprintf(stdout, "FTB %08lx", n);
+ return 4;
}
/* ************************************************************ */
#define NumberofAtoms 68
-static char *AtomTable[NumberofAtoms + 1] =
+static const char * const AtomTable[NumberofAtoms + 1] =
{
"NONE", "PRIMARY", "SECONDARY", "ARC", "ATOM", "BITMAP", "CARDINAL",
"COLORMAP", "CURSOR", "CUT_BUFFER0", "CUT_BUFFER1", "CUT_BUFFER2",
@@ -472,87 +487,92 @@ static char *AtomTable[NumberofAtoms + 1] =
the user defined ones, too. */
int
-PrintATOM(unsigned char *buf)
+PrintATOM(const unsigned char *buf)
{
/* print a ATOM -- CARD32 plus 0 = None */
long n = ILong (buf);
if (0 <= n && n <= NumberofAtoms)
fprintf(stdout, "<%s>", AtomTable[n]);
else
- fprintf(stdout, "ATM %08x", n);
+ fprintf(stdout, "ATM %08lx", n);
return(4);
}
int
-PrintATOMT(unsigned char *buf)
+PrintATOMT(const unsigned char *buf)
{
/* print a ATOMT -- CARD32 plus 0 = AnyPropertyType */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "AnyPropertyType");
+ fprintf(stdout, "AnyPropertyType");
else
- return PrintATOM(buf);
+ (void)PrintATOM(buf);
+ return 4;
}
int
-PrintVISUALID(unsigned char *buf)
+PrintVISUALID(const unsigned char *buf)
{
/* print a VISUALID -- CARD32 plus 0 = None */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "None");
+ fprintf(stdout, "None");
else
- return fprintf(stdout, "VIS %08x", n);
+ fprintf(stdout, "VIS %08lx", n);
+ return 4;
}
int
-PrintVISUALIDC(unsigned char *buf)
+PrintVISUALIDC(const unsigned char *buf)
{
/* print a VISUALIDC -- CARD32 plus 0 = CopyFromParent */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "CopyFromParent");
+ fprintf(stdout, "CopyFromParent");
else
- return PrintVISUALID(buf);
+ PrintVISUALID(buf);
+ return 4;
}
int
-PrintTIMESTAMP(unsigned char *buf)
+PrintTIMESTAMP(const unsigned char *buf)
{
/* print a TIMESTAMP -- CARD32 plus 0 as the current time */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "CurrentTime");
+ fprintf(stdout, "CurrentTime");
else
- return fprintf(stdout, "TIM %08x", n);
+ fprintf(stdout, "TIM %08lx", n);
+ return 4;
}
int
-PrintRESOURCEID(unsigned char *buf)
+PrintRESOURCEID(const unsigned char *buf)
{
/* print a RESOURCEID -- CARD32 plus 0 = AllTemporary */
long n = ILong (buf);
if (n == 0)
- return fprintf(stdout, "AllTemporary");
+ fprintf(stdout, "AllTemporary");
else
- return fprintf(stdout, "RID %08x", n);
+ fprintf(stdout, "RID %08lx", n);
+ return 4;
}
int
-PrintKEYSYM(unsigned char *buf)
+PrintKEYSYM(const unsigned char *buf)
{
/* print a KEYSYM -- CARD32 */
long n = ILong (buf);
- fprintf(stdout, "KYS %08x", n);
+ fprintf(stdout, "KYS %08lx", n);
return(4);
}
int
-PrintKEYCODE(unsigned char *buf)
+PrintKEYCODE(const unsigned char *buf)
{
/* print a KEYCODE -- CARD8 */
unsigned short n = IByte (buf);
@@ -561,51 +581,55 @@ PrintKEYCODE(unsigned char *buf)
}
int
-PrintKEYCODEA(unsigned char *buf)
+PrintKEYCODEA(const unsigned char *buf)
{
/* print a KEYCODEA -- CARD8 plus 0 = AnyKey */
long n = IByte (buf);
if (n == 0)
- return fprintf(stdout, "AnyKey");
+ fprintf(stdout, "AnyKey");
else
- return PrintKEYCODE(buf);
+ (void)PrintKEYCODE(buf);
+ return 1;
}
int
-PrintBUTTON(unsigned char *buf)
+PrintBUTTON(const unsigned char *buf)
{
/* print a BUTTON -- CARD8 */
unsigned short n = IByte (buf);
- return fprintf(stdout, "%d (%s)", n, printrep(n));
+ fprintf(stdout, "%d (%s)", n, printrep(n));
+ return 1;
}
int
-PrintBUTTONA(unsigned char *buf)
+PrintBUTTONA(const unsigned char *buf)
{
/* print a BUTTONA -- CARD8 plus 0 = AnyButton */
long n = IByte (buf);
if (n == 0)
- return fprintf(stdout, "AnyButton");
+ fprintf(stdout, "AnyButton");
else
- return PrintBUTTON(buf);
+ PrintBUTTON(buf);
+ return 1;
}
/* this is an interesting cheat -- we call DecodeEvent to print an event */
/* should work, but its never been tried */
int
-PrintEVENTFORM(unsigned char *buf)
+PrintEVENTFORM(const unsigned char *buf)
{
/* print an EVENT_FORM -- event format */
DecodeEvent(-1, buf, (long)-1);
+ return 32;
}
/* ************************************************************ */
int
PrintENUMERATED(
- unsigned char *buf,
+ const unsigned char *buf,
short length,
struct ValueListEntry *ValueList)
{
@@ -624,16 +648,16 @@ PrintENUMERATED(
p = p->Next;
if (p != NULL)
- return fprintf(stdout, "%s", p->Name);
+ fprintf(stdout, "%s", p->Name);
else
- return fprintf(stdout, "**INVALID** (%d)", n);
+ fprintf(stdout, "**INVALID** (%ld)", n);
}
/* ************************************************************ */
int
PrintSET(
- unsigned char *buf,
+ const unsigned char *buf,
short length,
struct ValueListEntry *ValueList)
{
@@ -674,9 +698,9 @@ PrintSET(
}
if (MatchesAll)
- return fprintf(stdout, "<ALL>");
+ fprintf(stdout, "<ALL>");
else if (!FoundOne)
- return fprintf(stdout, "0");
+ fprintf(stdout, "0");
}
@@ -686,13 +710,16 @@ PrintSET(
/* ************************************************************ */
void
-PrintField(buf, start, length, FieldType, name)
- unsigned char *buf;
- short start;
- short length;
- short FieldType;
- char *name;
+PrintField (
+ const unsigned char *buf,
+ short start,
+ short length,
+ short FieldType,
+ const char *name)
{
+ if (Verbose == 0)
+ return;
+
if (length == 0)
return;
@@ -736,11 +763,12 @@ PrintField(buf, start, length, FieldType, name)
/* print a list of things. The things are of type <ListType>.
They start at <buf>. There are <number> things in the list */
-long PrintList(buf, number, ListType, name)
- unsigned char *buf;
- long number;
- short ListType;
- char *name;
+long
+PrintList (
+ const unsigned char *buf,
+ long number,
+ short ListType,
+ const char *name)
{
long n;
long i;
@@ -749,7 +777,7 @@ long PrintList(buf, number, ListType, name)
if (number == 0)
return(0);
- fprintf(stdout, "%s%20s: (%d)\n", Leader, name, number);
+ fprintf(stdout, "%s%20s: (%ld)\n", Leader, name, number);
if (Verbose < 2)
return(0);
@@ -787,10 +815,11 @@ long PrintList(buf, number, ListType, name)
/* print a list of STRs. Similar to PrintList
They start at <buf>. There are <number> things in the list */
-long PrintListSTR(buf, number, name)
- unsigned char *buf;
- long number;
- char *name;
+long
+PrintListSTR (
+ const unsigned char *buf,
+ long number,
+ const char *name)
{
long n;
long i;
@@ -799,7 +828,7 @@ long PrintListSTR(buf, number, name)
if (number == 0)
return(0);
- fprintf(stdout, "%s%20s: (%d)\n", Leader, name, number);
+ fprintf(stdout, "%s%20s: (%ld)\n", Leader, name, number);
if (Verbose < 2)
return(0);
@@ -827,9 +856,9 @@ long PrintListSTR(buf, number, name)
int
PrintBytes(
- unsigned char buf[],
+ const unsigned char *buf,
long number,
- char *name)
+ const char *name)
{
/* print a list of BYTE -- 8-bit character */
long i;
@@ -868,9 +897,9 @@ PrintBytes(
int
PrintString8(
- unsigned char buf[],
+ const unsigned char *buf,
int number,
- char *name)
+ const char *name)
{
short i;
@@ -890,11 +919,11 @@ PrintString8(
int
PrintString16(
- unsigned char buf[],
+ const unsigned char *buf,
int number,
- char *name)
+ const char *name)
{
- short i;
+ long i;
unsigned short c;
if (number == 0)
@@ -903,7 +932,7 @@ PrintString16(
fprintf(stdout, "%s%20s: \"", Leader, name);
for (i = 0; i < number; i += 2)
{
- c = IShort(&buf[i]);
+ c = IChar2B(&buf[i]);
fprintf(stdout, "%s", printrep(c));
}
fprintf(stdout, "\"\n");
@@ -911,6 +940,54 @@ PrintString16(
return(number);
}
+void
+PrintTString8(
+ const unsigned char *buf,
+ long number,
+ const char *name)
+{
+ long i;
+ int off;
+
+ if (number == 0)
+ return;
+
+ off = 0;
+ if (TranslateText)
+ off = 0x20;
+ fprintf(stdout, "%s%20s: \"", Leader, name);
+ for (i = 0; i < number; i++)
+ fprintf(stdout, "%s", printrep(buf[i] + off));
+ fprintf(stdout, "\"\n");
+}
+
+
+/* print a String of CHAR2B -- 16-bit characters */
+void
+PrintTString16(
+ const unsigned char *buf,
+ long number,
+ const char *name)
+{
+ long i;
+ unsigned short c;
+ int off;
+
+ if (number == 0)
+ return;
+
+ off = 0;
+ if (TranslateText)
+ off = 0x20;
+ fprintf(stdout, "%s%20s: \"", Leader, name);
+ for (i = 0; i < number; i += 2)
+ {
+ c = IChar2B(&buf[i]);
+ fprintf(stdout, "%s", printrep(c + off));
+ }
+ fprintf(stdout, "\"\n");
+}
+
/* ************************************************************ */
/* */
/* */
@@ -926,11 +1003,11 @@ PrintString16(
void
PrintValues(
- unsigned char *control,
+ const unsigned char *control,
int clength,
int ctype,
- unsigned char *values,
- char *name)
+ const unsigned char *values,
+ const char *name)
{
long cmask;
struct ValueListEntry *p;
@@ -955,7 +1032,11 @@ PrintValues(
{
if ((p->Value & cmask) != 0)
{
- short m = 4 - p->Length;
+ short m;
+ if (littleEndian)
+ m=0;
+ else
+ m = 4 - p->Length;
PrintField(values, m, p->Length, p->Type, p->Name);
values += 4;
}
@@ -972,11 +1053,11 @@ PrintValues(
/* PolyText8 and PolyText16 take lists of characters with possible
font changes in them. */
-int
+void
PrintTextList8(
- unsigned char *buf,
+ const unsigned char *buf,
int length,
- char *name)
+ const char *name)
{
short n;
@@ -987,24 +1068,24 @@ PrintTextList8(
if (n != 255)
{
PrintField(buf, 1, 1, INT8, "delta");
- PrintString8(&buf[2], n, "text item 8 string");
+ PrintTString8(&buf[2], (long)n, "text item 8 string");
buf += n + 2;
length -= n + 2;
}
else
{
PrintField(buf, 1, 4, FONT, "font-shift-id");
- buf += 5;
- length -= 5;
+ buf += 4;
+ length -= 4;
}
}
}
-int
+void
PrintTextList16(
- unsigned char *buf,
+ const unsigned char *buf,
int length,
- char *name)
+ const char *name)
{
short n;
@@ -1015,15 +1096,15 @@ PrintTextList16(
if (n != 255)
{
PrintField(buf, 1, 1, INT8, "delta");
- PrintString16(&buf[2], n, "text item 16 string");
+ PrintTString16(&buf[2], (long)n, "text item 16 string");
buf += n + 2;
length -= n + 2;
}
else
{
PrintField(buf, 1, 4, FONT, "font-shift-id");
- buf += 5;
- length -= 5;
+ buf += 4;
+ length -= 4;
}
}
}
@@ -1036,12 +1117,12 @@ PrintTextList16(
#define MAXline 78
-static void
+void
DumpHexBuffer(
- unsigned char *buf,
+ const unsigned char *buf,
long n)
{
- short i;
+ long i;
short column;
char h[6] /* one hex or octal character */ ;
@@ -1062,3 +1143,41 @@ DumpHexBuffer(
column += 3;
}
}
+
+void
+PrintValueRec (
+ unsigned long key,
+ unsigned long cmask,
+ short ctype)
+{
+ unsigned char *values;
+ struct ValueListEntry *p;
+ ValuePtr value;
+
+ value = GetValueRec (key);
+ if (!value)
+ return;
+ values = (unsigned char *) value->values;
+
+ /* now if it is zero, ignore and return */
+ if (cmask == 0)
+ return;
+
+ /* there are bits in the controlling bitmask, figure out which */
+ /* the ctype is a set type, so this code is similar to PrintSET */
+ ModifyIndentLevel(1);
+ for (p = TD[ctype].ValueList; p != NULL; p = p->Next)
+ {
+ if ((p->Value & cmask) != 0)
+ {
+ short m;
+ if (littleEndian)
+ m=0;
+ else
+ m = 4 - p->Length;
+ PrintField(values, m, p->Length, p->Type, p->Name);
+ }
+ values += 4;
+ }
+ ModifyIndentLevel(-1);
+}
diff --git a/randrscope.h b/randrscope.h
new file mode 100644
index 0000000..5b63b06
--- /dev/null
+++ b/randrscope.h
@@ -0,0 +1,29 @@
+#ifndef _RANDRSCOPE_H_
+#define _RANDRSCOPE_H_
+
+#define RANDRREQUESTHEADER "RANDRREQUEST"
+#define RANDRREPLYHEADER "RANDRREPLY"
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
+
+extern unsigned char RANDRRequest;
+extern unsigned char RANDREvent;
+
+extern void RandrQueryVersion (FD fd, const unsigned char *buf);
+extern void RandrQueryVersionReply (FD fd, const unsigned char *buf);
+extern void RandrGetScreenInfo (FD fd, const unsigned char *buf);
+extern void RandrGetScreenInfoReply (FD fd, const unsigned char *buf);
+extern void RandrSetScreenConfig (FD fd, const unsigned char *buf);
+extern void RandrSetScreenConfigReply (FD fd, const unsigned char *buf);
+extern void RandrScreenChangeSelectInput (FD fd, const unsigned char *buf);
+extern void RandrScreenSizes (const unsigned char *buf);
+extern void RandrScreenChangeNotifyEvent (const unsigned char *buf);
+
+#endif
+
diff --git a/renderscope.h b/renderscope.h
new file mode 100644
index 0000000..201e339
--- /dev/null
+++ b/renderscope.h
@@ -0,0 +1,58 @@
+#ifndef _RENDERSCOPE_H_
+#define _RENDERSCOPE_H_
+
+#define RENDERREQUESTHEADER "RENDERREQUEST"
+#define RENDERREPLYHEADER "RENDERREPLY"
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
+
+extern unsigned char RENDERRequest;
+extern unsigned char RENDERError;
+#define RENDERNError 5
+
+extern void RenderQueryVersion (FD fd, const unsigned char *buf);
+extern void RenderQueryVersionReply (FD fd, const unsigned char *buf);
+extern void RenderQueryPictFormats (FD fd, const unsigned char *buf);
+extern void RenderQueryPictFormatsReply (FD fd, const unsigned char *buf);
+extern void RenderQueryPictIndexValues (FD fd, const unsigned char *buf);
+extern void RenderQueryPictIndexValuesReply (FD fd, const unsigned char *buf);
+extern void RenderQueryDithers (FD fd, const unsigned char *buf);
+extern void RenderQueryDithersReply (FD fd, const unsigned char *buf);
+extern void RenderCreatePicture (FD fd, const unsigned char *buf);
+extern void RenderChangePicture (FD fd, const unsigned char *buf);
+extern void RenderSetPictureClipRectangles (FD fd, const unsigned char *buf);
+extern void RenderFreePicture (FD fd, const unsigned char *buf);
+extern void RenderComposite (FD fd, const unsigned char *buf);
+extern void RenderScale (FD fd, const unsigned char *buf);
+extern void RenderTrapezoids (FD fd, const unsigned char *buf);
+extern void RenderTriangles (FD fd, const unsigned char *buf);
+extern void RenderTriStrip (FD fd, const unsigned char *buf);
+extern void RenderTriFan (FD fd, const unsigned char *buf);
+extern void RenderColorTrapezoids (FD fd, const unsigned char *buf);
+extern void RenderColorTriangles (FD fd, const unsigned char *buf);
+extern void RenderTransform (FD fd, const unsigned char *buf);
+extern void RenderCreateGlyphSet (FD fd, const unsigned char *buf);
+extern void RenderReferenceGlyphSet (FD fd, const unsigned char *buf);
+extern void RenderFreeGlyphSet (FD fd, const unsigned char *buf);
+extern void RenderAddGlyphs (FD fd, const unsigned char *buf);
+extern void RenderAddGlyphsFromPicture (FD fd, const unsigned char *buf);
+extern void RenderFreeGlyphs (FD fd, const unsigned char *buf);
+extern void RenderCompositeGlyphs8 (FD fd, const unsigned char *buf);
+extern void RenderCompositeGlyphs16 (FD fd, const unsigned char *buf);
+extern void RenderCompositeGlyphs32 (FD fd, const unsigned char *buf);
+extern void RenderFillRectangles (FD fd, const unsigned char *buf);
+
+extern void RenderPictFormatError (FD fd, const unsigned char *buf);
+extern void RenderPictureError (FD fd, const unsigned char *buf);
+extern void RenderPictOpError (FD fd, const unsigned char *buf);
+extern void RenderGlyphSetError (FD fd, const unsigned char *buf);
+extern void RenderGlyphError (FD fd, const unsigned char *buf);
+
+#endif
+
diff --git a/scope.c b/scope.c
index 32c80c6..45f2724 100644
--- a/scope.c
+++ b/scope.c
@@ -54,89 +54,618 @@
***************************************************** */
#include "scope.h"
+#include "nas.h"
-#include <errno.h>
+#include <ctype.h>
#include <unistd.h>
-#include <netdb.h>
#ifdef SYSV
#define bzero(s,l) memset(s, 0, l)
#define bcopy(s,d,l) memmove(d,s,l)
#endif
+#include <sys/types.h> /* needed by sys/socket.h and netinet/in.h */
+#include <sys/uio.h> /* for struct iovec, used by socket.h */
+#include <sys/socket.h> /* for AF_INET, SOCK_STREAM, ... */
+#include <sys/ioctl.h> /* for FIONCLEX, FIONBIO, ... */
+#ifdef SVR4
+#include <sys/filio.h>
+#endif
+#include <fcntl.h>
+#include <netinet/in.h> /* struct sockaddr_in */
+#include <netinet/tcp.h>
+#include <netdb.h> /* struct servent * and struct hostent * */
+#include <errno.h> /* for EINTR, EADDRINUSE, ... */
+
+
/* ********************************************** */
/* */
/* ********************************************** */
#define DefaultPort 6000
-static char ServerHostName[MAXHOSTNAMELEN];
+ char ServerHostName[MAXHOSTNAMELEN];
+ char AudioServerHostName[MAXHOSTNAMELEN];
long ServerBasePort = DefaultPort;
static long ServerInPort = 1;
static long ServerOutPort = 0;
static long ServerDisplay = 0;
-#ifdef USE_XTRANS
-#undef DNETCONN
-#undef DNETSVR4
-#endif
+static FD ConnectToClient(FD ConnectionSocket);
+static void DataFromClient(FD fd);
+static void SetUpStdin(void);
-#ifdef DNETCONN
-#include <X11/dni.h>
-#include <sys/fcntl.h>
-int decnet_in = 0;
-int decnet_out = 0;
-int decnet_server = 0;
-#endif
-#ifdef DNETSVR4
-#include <X11/dni8.h>
-extern struct hostent *(*dnet_gethostbyname)();
-extern int (*dnet_gethostname)();
-short initialize_libdni();
-int decnet_in = 0;
-int decnet_out = 0;
-int decnet_server = 0;
+long TranslateText = 0;
+char ScopeEnabled = 1;
+char HandleSIGUSR1 = 0;
+char DoAudio = 0;
+char TerminateClose = 0;
+int Interrupt = 0;
+
+struct FDDescriptor *FDD = NULL;
+short MaxFD = 0;
+short nFDsInUse = 0;
+fd_set ReadDescriptors;
+fd_set WriteDescriptors;
+fd_set BlockedReadDescriptors;
+short HighestFD;
+
+short debuglevel = 0;
+short Verbose = 0;
+short XVerbose = 0;
+short NasVerbose = 0;
+int ScopePort = 0;
+char *ScopeHost = NULL;
+
+
+typedef struct _BreakPoint {
+ struct _BreakPoint *next;
+ int number;
+ unsigned char request;
+ Boolean enabled;
+} BP;
+
+typedef enum _CMDResult { CMDProceed, CMDDebug, CMDSyntax, CMDError } CMDResult;
+
+static CMDResult CMDStep (int argc, char **argv);
+static CMDResult CMDCont (int argc, char **argv);
+static CMDResult CMDBreak (int argc, char **argv);
+static CMDResult CMDDelete (int argc, char **argv);
+static CMDResult CMDDisable (int argc, char **argv);
+static CMDResult CMDEnable (int argc, char **argv);
+static CMDResult CMDLevel (int argc, char **argv);
+static CMDResult CMDAudio (int argc, char **argv);
+static CMDResult CMDQuit (int argc, char **argv);
+static CMDResult CMDHelp (int argc, char **argv);
+
+typedef struct _CMDFunc {
+ char *name;
+ char *alias;
+ CMDResult (*func)(int argc, char **argv);
+ char *usage;
+ char *help;
+} CMDFuncRec;
+typedef const CMDFuncRec *CMDFuncPtr;
+
+static const CMDFuncRec CMDFuncs[] = {
+ { "audio", "a", CMDAudio, "[a]udio",
+ "Set audio output level\n" },
+ { "break", "b", CMDBreak, "[b]reak",
+ "Create breakpoints\n" },
+ { "cont", "c", CMDCont, "[c]ont",
+ "Continue scoping\n" },
+ { "delete", "del", CMDDelete, "[del]ete",
+ "Delete breakpoints\n" },
+ { "disable","d", CMDDisable, "[d]isable",
+ "Disable breakpoints\n" },
+ { "enable", "e", CMDEnable, "[e]nable",
+ "Enable breakpoints\n" },
+ { "help", "?", CMDHelp, "help",
+ "Print this list\n" },
+ { "level", "l", CMDLevel, "[l]evel",
+ "Set output level\n" },
+ { "quit", "q", CMDQuit, "[q]uit",
+ "Quit Xscope\n" },
+ { "step", "s", CMDStep, "[s]tep",
+ "Step trace one request\n" },
+};
+
+#define NumCMDFuncs (sizeof CMDFuncs / sizeof CMDFuncs[0])
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE 1
#endif
-static FD ConnectToClient(FD ConnectionSocket);
-static FD ConnectToServer(int report);
-static void SetUpStdin(void);
+static int
+CMDStringToInt (
+ char *s,
+ int *v)
+{
+ int sign = 1;
+
+ switch (*s) {
+ case '-':
+ sign = -1;
+ s++;
+ break;
+ case '+':
+ s++;
+ break;
+ }
+
+ if (!strncmp (s, "0x", 2))
+ {
+ sscanf (s + 2, "%x", v);
+ }
+ else if (*s == '0')
+ {
+ sscanf (s, "%o", v);
+ }
+ else if (isdigit (*s))
+ {
+ sscanf (s, "%d", v);
+ }
+ else if (*s == '\'')
+ {
+ s++;
+ if (*s == '\\') {
+ s++;
+ switch (*s) {
+ case 'n':
+ *v = '\n';
+ break;
+ case 't':
+ *v = '\t';
+ break;
+ default:
+ *v = (int) *s;
+ break;
+ }
+ } else
+ *v = (int) *s;
+ s++;
+ if (*s != '\'')
+ return FALSE;
+ }
+ else
+ return FALSE;
+ *v *= sign;
+ return TRUE;
+}
+
+static CMDFuncPtr
+CMDStringToFunc (
+ const char *name)
+{
+ int i;
+ for (i = 0; i < NumCMDFuncs; i++)
+ {
+ if (!strcmp (name, CMDFuncs[i].name) ||
+ !strcmp (name, CMDFuncs[i].alias))
+ {
+ return &CMDFuncs[i];
+ }
+ }
+ return NULL;
+}
+
+static int
+CMDSplitIntoWords (
+ char *line,
+ char **argv)
+{
+ char quotechar;
+ int argc;
+
+ argc = 0;
+ while (*line) {
+ while (isspace(*line))
+ line++;
+ if (!*line)
+ break;
+ if (*line == '"')
+ {
+ quotechar = *line++;
+ *argv++ = line;
+ argc++;
+ while (*line && *line != quotechar)
+ line++;
+ if (*line)
+ *line++ = '\0';
+ }
+ else
+ {
+ *argv++ = line;
+ argc++;
+ while (*line && !isspace(*line))
+ line++;
+ if (*line)
+ *line++ = '\0';
+ }
+ }
+ *argv = NULL;
+ return argc;
+}
+
+static CMDResult
+CMDHelp(
+ int argc,
+ char **argv)
+{
+ int i;
+ CMDFuncPtr func;
+
+ if (argc == 1)
+ {
+ for (i = 0; i < NumCMDFuncs; i++)
+ printf("%-10s%s\n", CMDFuncs[i].name, CMDFuncs[i].usage);
+ }
+ else
+ {
+ for (i = 1; i < argc; i++)
+ {
+ func = CMDStringToFunc (argv[i]);
+ if (!func)
+ {
+ printf ("%-10s unknown command\n", argv[i]);
+ return CMDSyntax;
+ }
+ printf ("%-10s %s\n%s", func->name, func->usage, func->help);
+ }
+ }
+ return CMDDebug;
+}
+
+static void
+CMDSyntaxError(
+ int argc,
+ char **argv)
+{
+ printf("Syntax error in:");
+ while (*argv)
+ printf(" %s", *argv++);
+ printf("\n");
+}
+
+void
+ReadCommands (void)
+{
+ int argc;
+ char line[1024];
+ char *argv[20];
+ CMDResult result;
+ CMDFuncPtr func;
+ static int here;
+
+ if (here)
+ return;
+ here = 1;
+ for (;;) {
+ printf ("> ");
+ if (!fgets (line, sizeof line, stdin))
+ break;
+ argc = CMDSplitIntoWords(line, argv);
+ if (argc > 0) {
+ func = CMDStringToFunc (argv[0]);
+ if (!func)
+ CMDSyntaxError (argc, argv);
+ else
+ {
+ result = (*func->func)(argc, argv);
+ switch (result) {
+ case CMDSyntax:
+ CMDSyntaxError(argc, argv);
+ break;
+ case CMDError:
+ printf ("Error\n");
+ break;
+ case CMDProceed:
+ here = 0;
+ return;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ printf("...\n");
+ here = 0;
+}
+
+int SingleStep;
+int BreakPoint;
+BP *breakPoints;
+int breakPointNumber;
+
+void
+TestBreakPoints (
+ const unsigned char *buf,
+ long n)
+{
+ BP *bp;
+
+ for (bp = breakPoints; bp; bp = bp->next)
+ {
+ if (bp->request == buf[0])
+ {
+ break;
+ }
+ }
+ if (bp)
+ {
+ printf ("Breakpoint on request %d\n", bp->request);
+ ReadCommands ();
+ }
+}
+
+static void
+setBreakPoint (void)
+{
+ Boolean b = false;
+ BP *bp;
+ FD fd;
+
+ if (SingleStep)
+ b = true;
+ else
+ {
+ for (bp = breakPoints; bp; bp = bp->next)
+ {
+ if (bp->enabled)
+ {
+ b = true;
+ break;
+ }
+ }
+ }
+ if (b != BreakPoint)
+ {
+ BreakPoint = b;
+ for (fd = 0; fd < HighestFD; fd++)
+ {
+ if (FDD[fd].Busy && FDD[fd].InputHandler == DataFromClient)
+ {
+ if (BreakPoint)
+ SetBufLimit (fd);
+ else
+ ClearBufLimit (fd);
+ }
+ }
+ }
+}
+
+static CMDResult
+CMDBreak (
+ int argc,
+ char **argv)
+{
+ BP *bp, **prev;
+ int request;
+
+ if (argc == 1)
+ {
+ for (bp = breakPoints; bp; bp = bp->next)
+ {
+ printf ("%3d: %3d %s\n", bp->number, bp->request,
+ bp->enabled ? "enabled" : "disabled");
+ }
+ }
+ else
+ {
+ for (prev = &breakPoints; *prev; prev = &(*prev)->next);
+ while (*++argv) {
+ request = GetXRequestFromName (*argv);
+ if (request < 0 && !CMDStringToInt (*argv, &request))
+ return CMDSyntax;
+ bp = (BP *) malloc (sizeof (BP));
+ bp->request = request;
+ bp->number = ++breakPointNumber;
+ bp->enabled = true;
+ bp->next = NULL;
+ *prev = bp;
+ prev = &bp->next;
+ }
+ }
+ setBreakPoint ();
+ return CMDDebug;
+}
+
+static CMDResult
+CMDCont (
+ int argc,
+ char **argv)
+{
+ SingleStep = 0;
+ return CMDProceed;
+}
+
+static CMDResult
+CMDDisable (
+ int argc,
+ char **argv)
+{
+ BP *bp;
+ int number;
+
+ if (argc == 1)
+ {
+ printf ("Disabling all breakpoints...\n");
+ for (bp = breakPoints; bp; bp = bp->next)
+ bp->enabled = false;
+ }
+ else
+ {
+ while (*++argv) {
+ if (!CMDStringToInt (*argv, &number))
+ return CMDSyntax;
+ for (bp = breakPoints; bp; bp = bp->next)
+ if (bp->number == number)
+ {
+ bp->enabled = false;
+ break;
+ }
+ if (!bp)
+ {
+ printf ("No such breakpoint %s\n", *argv);
+ }
+ }
+ }
+ setBreakPoint ();
+ return CMDDebug;
+}
+
+static CMDResult
+CMDDelete (
+ int argc,
+ char **argv)
+{
+ BP *bp, **prev;
+ int number;
+
+ if (argc == 1)
+ {
+ printf ("Deleting all breakpoints...\n");
+ while ((bp = breakPoints) != NULL)
+ {
+ breakPoints = bp->next;
+ free (bp);
+ }
+ }
+ else
+ {
+ while (*++argv) {
+ if (!CMDStringToInt (*argv, &number))
+ return CMDSyntax;
+ for (prev = &breakPoints; bp = *prev; prev = &bp->next)
+ {
+ if (bp->number == number)
+ {
+ *prev = bp->next;
+ free (bp);
+ break;
+ }
+ }
+ if (!bp)
+ {
+ printf ("No such breakpoint %s\n", *argv);
+ }
+ }
+ }
+ setBreakPoint ();
+ return CMDDebug;
+}
+
+static CMDResult
+CMDEnable (
+ int argc,
+ char **argv)
+{
+ BP *bp;
+ int number;
+
+ if (argc == 1)
+ {
+ printf ("Enablingg all breakpoints...\n");
+ for (bp = breakPoints; bp; bp = bp->next)
+ bp->enabled = true;
+ }
+ else
+ {
+ while (*++argv) {
+ if (!CMDStringToInt (*argv, &number))
+ return CMDSyntax;
+ for (bp = breakPoints; bp; bp = bp->next)
+ if (bp->number == number)
+ {
+ bp->enabled = true;
+ break;
+ }
+ if (!bp)
+ {
+ printf ("No such breakpoint %s\n", *argv);
+ }
+ }
+ }
+ setBreakPoint ();
+ return CMDDebug;
+}
+
+static CMDResult
+CMDStep (
+ int argc,
+ char **argv)
+{
+ SingleStep = 1;
+ setBreakPoint ();
+ return CMDProceed;
+}
+
+static CMDResult
+CMDQuit (
+ int argc,
+ char **argv)
+{
+ printf ("exiting...\n");
+ exit (0);
+}
+
+static CMDResult
+CMDLevel (
+ int argc,
+ char **argv)
+{
+ int level;
+
+ if (argc == 1)
+ printf ("Level: %d\n", XVerbose);
+ else if (argc == 2 && CMDStringToInt (argv[1], &level))
+ XVerbose = level;
+ else
+ return CMDSyntax;
+ return CMDDebug;
+}
+
+static CMDResult
+CMDAudio (
+ int argc,
+ char **argv)
+{
+ int level;
+ if (argc == 1)
+ printf ("Audio Level: %d\n", NasVerbose);
+ else if (argc == 2 && CMDStringToInt (argv[1], &level))
+ NasVerbose = level;
+ else
+ return CMDSyntax;
+ return CMDDebug;
+}
/* ********************************************** */
/* */
/* */
/* ********************************************** */
-static short GetServerport ()
+short
+GetServerport (void)
{
short port;
enterprocedure("GetServerport");
-#if defined(DNETCONN) || defined(DNETSVR4)
- if (decnet_server) {
- port = ServerDisplay + ServerOutPort;
- return(port);
- }
-#endif
port = ServerBasePort + ServerOutPort + ServerDisplay;
debug(4,(stderr, "Server service is on port %d\n", port));
return(port);
}
-static short GetScopePort ()
+static short
+GetScopePort (void)
{
short port;
enterprocedure("GetScopePort");
-#if defined(DNETCONN) || defined(DNETSVR4)
- if (decnet_in) {
- port = ServerInPort + ServerDisplay;
- return(port);
- }
-#endif
port = ServerBasePort + ServerInPort + ServerDisplay;
debug(4,(stderr, "scope service is on port %d\n", port));
return(port);
@@ -147,7 +676,7 @@ static short GetScopePort ()
/* ********************************************** */
static void
-Usage()
+Usage(void)
{
fprintf(stderr, "Usage: xscope\n");
fprintf(stderr, " [-h<server-host>]\n");
@@ -158,20 +687,22 @@ Usage()
#ifdef RAW_MODE
fprintf(stderr, " [-r] -- raw output\n");
#endif
+ fprintf(stderr, " [-a<n>] -- audio verbose output\n");
fprintf(stderr, " [-q] -- quiet output\n");
fprintf(stderr, " [-D<debug-level>]\n");
+ fprintf(stderr, " [-S<n>] -- start/stop on SIGUSR1\n");
+ fprintf(stderr, " [-t] -- terminate when all clients close\n");
exit(1);
}
+
static void
-ScanArgs(argc, argv)
- int argc;
- char **argv;
+ScanArgs (
+ int argc,
+ char **argv)
{
-#if defined(DNETCONN) || defined(DNETSVR4)
- char *ss;
-#endif
- Verbose = 1 /* default verbose-ness level */;
+ XVerbose = 1 /* default verbose-ness level */;
+ NasVerbose = 1;
#ifdef RAW_MODE
Raw = 0 ;
#endif
@@ -196,19 +727,18 @@ ScanArgs(argc, argv)
debuglevel = atoi(++*argv);
if (debuglevel == 0)
debuglevel = 255;
- debuglevel |= 1;
- Verbose = 7;
+ XVerbose = 7;
debug(1,(stderr, "debuglevel = %d\n", debuglevel));
break;
- case 'q': /* quiet mode */
- Verbose = 0;
- debug(1,(stderr, "Verbose = %d\n", Verbose));
+ case 'S':
+ HandleSIGUSR1 = 1;
+ ScopeEnabled = atoi(++*argv);
break;
- case 'v': /* verbose mode */
- Verbose = atoi(++*argv);
- debug(1,(stderr, "Verbose = %d\n", Verbose));
+ case 'q': /* quiet mode */
+ XVerbose = 0;
+ debug(1,(stderr, "Verbose = %d\n", XVerbose));
break;
#ifdef RAW_MODE
@@ -218,48 +748,61 @@ ScanArgs(argc, argv)
break;
#endif
+ case 'v': /* verbose mode */
+ XVerbose = atoi(++*argv);
+ debug(1,(stderr, "Verbose = %d\n", XVerbose));
+ break;
+
case 'o':
ServerOutPort = atoi(++*argv);
if (ServerOutPort <= 0)
ServerOutPort = 0;
- debug(1,(stderr, "ServerOutPort = %d\n", ServerOutPort));
+ debug(1,(stderr, "ServerOutPort = %ld\n", ServerOutPort));
break;
case 'd':
ServerDisplay = atoi(++*argv);
if (ServerDisplay <= 0)
ServerDisplay = 0;
- debug(1,(stderr, "ServerDisplay=%d\n", ServerDisplay));
+ debug(1,(stderr, "ServerDisplay = %ld\n", ServerDisplay));
break;
case 'i':
-#if defined(DNETCONN) || defined(DNETSVR4)
- if (ss = (char *)strchr(*argv,':')) {
- decnet_in = 1;
- *ss = NULL;
- }
-#endif
ServerInPort = atoi(++*argv);
if (ServerInPort <= 0)
ServerInPort = 0;
- debug(1,(stderr, "ServerInPort = %d\n", ServerInPort));
+ debug(1,(stderr, "ServerInPort = %ld\n", ServerInPort));
break;
case 'h':
-#if defined(DNETCONN) || defined(DNETSVR4)
- if (ss = (char *)strchr(*argv,':')) {
- decnet_server = 1;
- *ss = NULL;
- strcpy(ServerHostName,++*argv);
- break;
- }
-#endif
if (++*argv != NULL && **argv != '\0'
&& (strlen(*argv) < sizeof(ServerHostName)))
strcpy(ServerHostName, *argv);
debug(1,(stderr, "ServerHostName=%s\n", ServerHostName));
break;
+ case 'T':
+ TranslateText = 1;
+ break;
+
+ case 'A':
+ DoAudio = 1;
+ break;
+
+ case 'a': /* verbose mode */
+ NasVerbose = atoi(++*argv);
+ debug(1,(stderr, "NasVerbose = %d\n", NasVerbose));
+ break;
+
+ case 'n': /* NAS server host */
+ if (++*argv != NULL && **argv != '\0')
+ (void)strcpy(AudioServerHostName, *argv);
+ debug(1,(stderr, "AudioServerHostName=%s\n", AudioServerHostName));
+ break;
+ case 't':
+ TerminateClose = 1;
+ break;
+
default:
fprintf(stderr, "Unknown option %c\n", **argv);
Usage();
@@ -277,7 +820,7 @@ ScanArgs(argc, argv)
if (ServerInPort == ServerOutPort)
if (ServerHostName[0] == '\0')
{
- fprintf(stderr, "Can't have xscope on same port as server (%d)\n",
+ fprintf(stderr, "Can't have xscope on same port as server (%ld)\n",
ServerInPort);
Usage();
}
@@ -289,29 +832,27 @@ ScanArgs(argc, argv)
/* */
/* ********************************************** */
-main(argc, argv)
- int argc;
- char **argv;
+int
+main (
+ int argc,
+ char **argv)
{
ScanArgs(argc, argv);
InitializeFD();
InitializeX11();
+ if (DoAudio)
+ InitializeAudio();
SetUpStdin();
-#if defined(DNETCONN) || defined(DNETSVR4)
- if (decnet_in)
- SetUpDECnetConnection(GetScopePort());
- else
- SetUpConnectionSocket(GetScopePort());
-#else
- SetUpConnectionSocket(GetScopePort());
+ SetUpConnectionSocket(GetScopePort(), NewConnection);
+ if (DoAudio)
+ SetUpConnectionSocket (GetScopePort() + 2000, NewAudio);
SetSignalHandling();
-#endif
return MainLoop();
}
void
-TimerExpired()
+TimerExpired (void)
{
debug(16,(stderr, "Timer tick\n"));
}
@@ -333,22 +874,22 @@ TimerExpired()
*/
static void
-ReadStdin(fd)
- FD fd;
+ReadStdin (
+ FD fd)
{
char buf[2048];
long n;
enterprocedure("ReadStdin");
n = read(fd, buf, 2048);
- debug(4,(stderr, "read %d bytes from stdin\n", n));
+ debug(4,(stderr, "read %ld bytes from stdin\n", n));
}
static void
-SetUpStdin()
+SetUpStdin (void)
{
enterprocedure("SetUpStdin");
- UsingFD(fileno(stdin), ReadStdin, NULL);
+ UsingFD(fileno(stdin), ReadStdin, NULL, NULL);
}
/* ************************************************************ */
@@ -365,32 +906,31 @@ SetUpStdin()
we get input from one, we can write it to the other.
*/
-struct fdinfo
-{
- Boolean Server;
- long ClientNumber;
- FD pair;
-};
-
-static long ClientNumber = 0;
-static struct fdinfo FDinfo[StaticMaxFD];
+static long clientNumber = 0;
+struct fdinfo FDinfo[StaticMaxFD];
-static void
-SetUpPair(client, server)
- FD client;
- FD server;
+void
+SetUpPair(
+ FD client,
+ FD server)
{
if (client >= 0)
{
- ClientNumber += 1;
+ clientNumber += 1;
FDinfo[client].Server = false;
FDinfo[client].pair = server;
- FDinfo[client].ClientNumber = ClientNumber;
+ FDinfo[client].ClientNumber = clientNumber;
+ FDinfo[client].bufcount = 0;
+ FDinfo[client].buflimit = -1;
+ FDinfo[client].bufdelivered = 0;
if (server >= 0)
{
FDinfo[server].Server = true;
FDinfo[server].pair = client;
FDinfo[server].ClientNumber = FDinfo[client].ClientNumber;
+ FDinfo[server].bufcount = 0;
+ FDinfo[server].buflimit = -1;
+ FDinfo[server].bufdelivered = 0;
}
}
else if (server >= 0)
@@ -401,10 +941,30 @@ SetUpPair(client, server)
}
static void
-CloseConnection(fd)
- FD fd;
+ResetPair (
+ FD client,
+ FD server)
+{
+ if (client >= 0)
+ {
+ FDinfo[client].bufcount = 0;
+ FDinfo[client].buflimit = -1;
+ FDinfo[client].bufdelivered = 0;
+ }
+ if (server >= 0)
+ {
+ FDinfo[server].bufcount = 0;
+ FDinfo[server].buflimit = -1;
+ FDinfo[server].bufdelivered = 0;
+ }
+}
+
+static void
+CloseConnection (
+ FD fd)
{
debug(4,(stderr, "close %d and %d\n", fd, FDPair(fd)));
+ ResetPair (ClientHalf(fd), ServerHalf(fd));
StopClientConnection(ServerHalf(fd));
StopServerConnection(ClientHalf(fd));
@@ -417,63 +977,148 @@ CloseConnection(fd)
#endif
NotUsingFD(fd);
NotUsingFD(FDPair(fd));
+ if (TerminateClose)
+ exit (0);
}
/* ************************************************************ */
-FD FDPair(fd)
- FD fd;
+FD
+FDPair (
+ FD fd)
{
return(FDinfo[fd].pair);
}
-FD ClientHalf(fd)
- FD fd;
+FD
+ClientHalf (
+ FD fd)
{
if (FDinfo[fd].Server)
return(FDinfo[fd].pair);
return(fd);
}
-FD ServerHalf(fd)
- FD fd;
+FD
+ServerHalf (
+ FD fd)
{
if (FDinfo[fd].Server)
return(fd);
return(FDinfo[fd].pair);
}
-char *ClientName (fd)
- FD fd;
+char *
+ClientName (
+ FD fd)
{
static char name[12];
- if (ClientNumber <= 1)
+ if (clientNumber <= 1)
return("");
- sprintf(name, " %d", FDinfo[fd].ClientNumber);
+ (void)sprintf(name, " %ld", FDinfo[fd].ClientNumber);
return(name);
}
+int
+ClientNumber (
+ FD fd)
+{
+ return FDinfo[fd].ClientNumber;
+}
/* ********************************************** */
/* */
/* ********************************************** */
+/*
+ * Write as much of the queued data as the receiver will accept
+ * Block reads from the sender until the receiver gets all of the
+ * data
+ */
+void
+FlushFD (
+ FD fd)
+{
+ long BytesToWrite = FDinfo[fd].bufcount - FDinfo[fd].bufstart;
+ unsigned char *p = FDinfo[fd].buffer + FDinfo[fd].bufstart;
+ int PeerFD;
+
+ PeerFD = FDPair (fd);
+ if (FDinfo[fd].buflimit >= 0)
+ {
+ if (FDinfo[fd].bufdelivered + BytesToWrite > FDinfo[fd].buflimit)
+ BytesToWrite = FDinfo[fd].buflimit - FDinfo[fd].bufdelivered;
+ }
+ while (BytesToWrite > 0)
+ {
+ int n1 = write (fd, (char *)p, (int)BytesToWrite);
+ debug(4,(stderr, "write %d bytes\n", n1));
+ if (n1 < 0)
+ {
+ if (errno != EWOULDBLOCK && errno != EAGAIN)
+ {
+ perror("Error on write");
+ if (PeerFD >= 0)
+ CloseConnection(PeerFD);
+ BytesToWrite = 0;
+ }
+ break;
+ }
+ else
+ {
+ FDinfo[fd].bufstart += n1;
+ FDinfo[fd].bufdelivered += n1;
+ BytesToWrite -= n1;
+ p += n1;
+ }
+ }
+ if (FDinfo[fd].bufstart == FDinfo[fd].bufcount)
+ {
+ if (PeerFD >= 0) {
+ FD_CLR(PeerFD, &BlockedReadDescriptors);
+ }
+ FD_CLR(fd, &WriteDescriptors);
+ FDinfo[fd].bufcount = FDinfo[fd].bufstart = 0;
+ }
+ else
+ {
+ if (PeerFD >= 0) {
+ FD_SET(PeerFD, &BlockedReadDescriptors);
+ }
+ if (FDinfo[fd].buflimit != FDinfo[fd].bufdelivered) {
+ FD_SET(PeerFD, &WriteDescriptors);
+ }
+ }
+}
+
/* when we get data from a client, we read it in, copy it to the
server for this client, then dump it to the client. Note, we don't
have to have a server, if there isn't one. */
static void
-DataFromClient(fd)
- FD fd;
+DataFromClient (
+ FD fd)
{
- unsigned char buf[2048];
long n;
FD ServerFD;
+ Verbose = XVerbose;
enterprocedure("DataFromClient");
- n = read(fd, (char *)buf, 2048);
- debug(4,(stderr, "read %d bytes from Client%s\n", n, ClientName(fd)));
+ ServerFD = FDPair(fd);
+ if (ServerFD < 0)
+ {
+ ServerFD = ConnectToServer(false);
+ if (ServerFD < 0)
+ {
+ CloseConnection(fd);
+ return;
+ }
+ SetUpPair(fd, ServerFD);
+ }
+
+ n = read(fd, FDinfo[ServerFD].buffer, BUFFER_SIZE);
+ debug(4,(stderr, "read %ld bytes from Client%s\n", n, ClientName(fd)));
if (n < 0)
{
PrintTime();
@@ -484,58 +1129,18 @@ DataFromClient(fd)
if (n == 0)
{
PrintTime();
- fprintf(stdout, "Client%s --> EOF\n", ClientName(fd));
+ if (Verbose >= 0)
+ fprintf(stdout, "Client%s --> EOF\n", ClientName(fd));
CloseConnection(fd);
return;
}
- ServerFD = FDPair(fd);
- if (ServerFD < 0)
- {
- ServerFD = ConnectToServer(false);
- SetUpPair(fd, ServerFD);
- }
-
- /* write bytes from client to server, allow for server to fail */
- if (ServerFD >= 0)
- {
- long BytesToWrite = n;
- unsigned char *p = buf;
-
- while (BytesToWrite > 0)
- {
- int n1 = write (ServerFD, (char *)p, (int)BytesToWrite);
- debug(4,(stderr, "write %d bytes to Server%s\n", n1, ClientName(fd)));
- if (n1 > 0)
- {
- BytesToWrite -= n1;
- p += n1;
- }
- /*
- B U G : 4156754
-
- Write may fail with an error code of EAGAIN if
- BytesToWrite is less than PIPE_BUF, but bigger
- than available free space. This error says, wait
- and try again till PIPE is flushed and has more
- free space.
- */
- else if (errno == EAGAIN)
- {
- /* Wait for some time and try again */
- sleep (1);
- }
- else
- {
- perror("Error on write to Server");
- CloseConnection(fd);
- BytesToWrite = 0;
- }
- }
- }
+ FDinfo[ServerFD].bufcount = n;
+ FDinfo[ServerFD].bufstart = 0;
+ FlushFD (ServerFD);
/* also report the bytes to standard out */
- ReportFromClient(fd, buf, n);
+ ReportFromClient(fd, FDinfo[ServerFD].buffer, n);
}
/* ********************************************** */
@@ -546,16 +1151,23 @@ DataFromClient(fd)
we close the connection down -- don't need a server with no client. */
static void
-DataFromServer(fd)
- FD fd;
+DataFromServer (
+ FD fd)
{
- unsigned char buf[2048];
long n;
FD ClientFD;
+ Verbose = XVerbose;
+ ClientFD = FDPair(fd);
+ if (ClientFD < 0)
+ {
+ CloseConnection(fd);
+ return;
+ }
+
enterprocedure("DataFromServer");
- n = read(fd, (char *)buf, 2048);
- debug(4,(stderr, "read %d bytes from Server%s\n", n, ClientName(fd)));
+ n = read(fd, (char *)FDinfo[ClientFD].buffer, BUFFER_SIZE);
+ debug(4,(stderr, "read %ld bytes from Server%s\n", n, ClientName(fd)));
if (n < 0)
{
PrintTime();
@@ -566,56 +1178,18 @@ DataFromServer(fd)
if (n == 0)
{
PrintTime();
- fprintf(stdout, "EOF <-- Server%s\n", ClientName(fd));
+ if (Verbose >= 0)
+ fprintf(stdout, "EOF <-- Server%s\n", ClientName(fd));
CloseConnection(fd);
return;
}
- ClientFD = FDPair(fd);
- if (ClientFD < 0)
- {
- CloseConnection(fd);
- return;
- }
-
- /* write bytes from server to client, allow for client to fail */
- {
- long BytesToWrite = n;
- unsigned char *p = buf;
- while (BytesToWrite > 0)
- {
- int n1 = write (ClientFD, (char *)p, (int)BytesToWrite);
- debug(4,(stderr, "write %d bytes to Client%s\n", n1, ClientName(fd)));
- if (n1 > 0)
- {
- BytesToWrite -= n1;
- p += n1;
- }
- /*
- B U G : 4156754
-
- Write may fail with an error code of EAGAIN if
- BytesToWrite is less than PIPE_BUF, but bigger
- than available free space. This error says, wait
- and try again till PIPE is flushed and has more
- free space.
- */
- else if (errno == EAGAIN)
- {
- /* Wait for some time and try again */
- sleep (1);
- }
- else
- {
- perror("Error on write to Client");
- CloseConnection(fd);
- BytesToWrite = 0;
- }
- }
- }
+ FDinfo[ClientFD].bufcount = n;
+ FDinfo[ClientFD].bufstart = 0;
+ FlushFD (ClientFD);
/* also report the bytes to standard out */
- ReportFromServer(fd, buf, n);
+ ReportFromServer(fd, FDinfo[ClientFD].buffer, n);
}
@@ -626,59 +1200,23 @@ DataFromServer(fd)
/* */
/* ************************************************************ */
-#include <sys/types.h> /* needed by sys/socket.h and netinet/in.h */
-#include <sys/uio.h> /* for struct iovec, used by socket.h */
-#include <sys/socket.h> /* for AF_INET, SOCK_STREAM, ... */
-#include <sys/ioctl.h> /* for FIONCLEX, FIONBIO, ... */
-#include <netinet/in.h> /* struct sockaddr_in */
-#include <netdb.h> /* struct servent * and struct hostent * */
-#include <errno.h> /* for EINTR, EADDRINUSE, ... */
-extern int errno;
-
-static int ON = 1 /* used in ioctl */ ;
void
-NewConnection(fd)
- FD fd;
+NewConnection (
+ FD fd)
{
- FD ServerFD = -1;
- FD ClientFD = -1;
-
-#ifdef DNETCONN
- if (decnet_in)
- ClientFD = ConnectToDECnetClient(fd);
- else
- ClientFD = ConnectToClient(fd);
- if (decnet_server)
- ServerFD = ConnectToDECnetServer(true);
- else
- ServerFD = ConnectToServer(true);
-#endif
-#ifdef DNETSVR4
- ClientFD = ConnectToClient(fd);
- if (decnet_server) {
- if (!initialize_libdni()) {
- fprintf(stderr,"Unable to open libdni.so\n");
- exit(0);
- }
- ServerFD = ConnectToDECnetSVR4Server(true);
- }
- else
- ServerFD = ConnectToServer(true);
-#endif
-#if !(defined(DNETCONN)) && !(defined(DNETSVR4))
- ClientFD = ConnectToClient(fd);
- ServerFD = ConnectToServer(true);
+ FD ClientFD = ConnectToClient(fd);
+ FD ServerFD = ConnectToServer(true);
-#endif
SetUpPair(ClientFD, ServerFD);
}
/* ************************************************************ */
-static FD ConnectToClient(ConnectionSocket)
- FD ConnectionSocket;
+static FD
+ConnectToClient (
+ FD ConnectionSocket)
{
FD ClientFD;
XtransConnInfo trans_conn = NULL;
@@ -688,6 +1226,7 @@ static FD ConnectToClient(ConnectionSocket)
#else
struct sockaddr_in from;
int len = sizeof (from);
+ int ON = 1 /* used in ioctl */ ;
#endif
enterprocedure("ConnectToClient");
@@ -701,7 +1240,7 @@ static FD ConnectToClient(ConnectionSocket)
_X11TransSetOption(trans_conn, TRANS_NONBLOCKING, 1);
ClientFD = _X11TransGetConnectionNumber(trans_conn);
#else
- ClientFD = accept(ConnectionSocket, (struct sockaddr *)&from, &len);
+ ClientFD = AcceptConnection(ConnectionSocket);
#endif
debug(4,(stderr, "Connect To Client: FD %d\n", ClientFD));
if (ClientFD < 0 && errno == EWOULDBLOCK)
@@ -715,7 +1254,7 @@ static FD ConnectToClient(ConnectionSocket)
panic("Can't connect to Client");
}
- UsingFD(ClientFD, DataFromClient, trans_conn);
+ UsingFD(ClientFD, DataFromClient, FlushFD, trans_conn);
#ifndef USE_XTRANS
ioctl(ClientFD, FIOCLEX, 0);
ioctl(ClientFD, FIONBIO, &ON);
@@ -731,31 +1270,20 @@ static FD ConnectToClient(ConnectionSocket)
-static FD ConnectToServer(report)
- Boolean report;
+FD
+ConnectToServer (
+ Boolean report)
{
FD ServerFD;
XtransConnInfo trans_conn = NULL; /* transport connection object */
-#ifdef USE_XTRANS
- char address[256];
- int connect_stat;
- extern long ServerBasePort;
-#else
- struct sockaddr_in sin;
- struct hostent *hp;
-#endif
short port;
enterprocedure("ConnectToServer");
- /* determine the host machine for this process */
- if (ServerHostName[0] == '\0')
- (void) gethostname(ServerHostName, sizeof (ServerHostName));
- debug(4,(stderr, "try to connect on %s\n", ServerHostName));
port = GetServerport ();
- if (port == ScopePort
- && strcmp(ServerHostName, ScopeHost) == 0)
+ if (port == ScopePort &&
+ ((ServerHostName[0] == '\0') || strcmp(ServerHostName, ScopeHost) == 0))
{
char error_message[100];
sprintf(error_message, "Trying to attach to myself: %s,%d\n",
@@ -763,233 +1291,13 @@ static FD ConnectToServer(report)
panic(error_message);
}
-#ifdef USE_XTRANS
- snprintf (address, sizeof(address), "%s:%d", ServerHostName,
- port - ServerBasePort);
- if ( (trans_conn = _X11TransOpenCOTSClient(address)) == NULL ) {
- debug(1,(stderr, "OpenCOTSClient failed\n"));
- panic("Can't open connection to Server");
- }
- if ((connect_stat = _X11TransConnect(trans_conn,address)) < 0 ) {
- _X11TransClose(trans_conn);
- trans_conn = NULL;
- debug(1,(stderr, "TransConnect failed\n"));
- panic("Can't open connection to Server");
- }
-
- ServerFD = _X11TransGetConnectionNumber(trans_conn);
-#else
- /* establish a socket to the name server for this host */
- bzero((char *)&sin, sizeof(sin));
- ServerFD = socket(AF_INET, SOCK_STREAM, 0);
- if (ServerFD < 0)
- {
- perror("socket() to Server failed");
- debug(1,(stderr, "socket failed\n"));
- panic("Can't open connection to Server");
- }
- (void) setsockopt(ServerFD, SOL_SOCKET, SO_REUSEADDR, (char *) NULL, 0);
- (void) setsockopt(ServerFD, SOL_SOCKET, SO_USELOOPBACK,(char *) NULL, 0);
-#ifdef SO_DONTLINGER
- (void) setsockopt(ServerFD, SOL_SOCKET, SO_DONTLINGER, (char *) NULL, 0);
-#endif
-
- hp = gethostbyname(ServerHostName);
- if (hp == 0)
- {
- perror("gethostbyname failed");
- debug(1,(stderr, "gethostbyname failed for %s\n", ServerHostName));
- panic("Can't open connection to Server");
- }
-
- sin.sin_family = AF_INET;
- bcopy((char *)hp->h_addr, (char *)&sin.sin_addr, hp->h_length);
- sin.sin_port = htons (port);
-
- /* ******************************************************** */
- /* try to connect to Server */
-
- if (connect(ServerFD, (struct sockaddr *)&sin, sizeof(sin)) < 0)
- {
- debug(4,(stderr, "connect returns errno of %d\n", errno));
- if (errno != 0)
- if (report)
- perror("connect");
- switch (errno)
- {
- case ECONNREFUSED:
- /* experience says this is because there is no Server
- to connect to */
- close(ServerFD);
- debug(1,(stderr, "No Server\n"));
- if (report)
- warn("Can't open connection to Server");
- return(-1);
-
- default:
- close(ServerFD);
- panic("Can't open connection to Server");
- }
- }
-#endif
+ ServerFD = MakeConnection (ServerHostName, port, report, &trans_conn);
debug(4,(stderr, "Connect To Server: FD %d\n", ServerFD));
if (ServerFD >= 0)
{
- UsingFD(ServerFD, DataFromServer, trans_conn);
+ UsingFD(ServerFD, DataFromServer, FlushFD, trans_conn);
StartServerConnection(ServerFD);
}
return(ServerFD);
}
-
-#ifdef DNETSVR4
-FD ConnectToDECnetSVR4Server(report)
- Boolean report;
-{
- FD ServerFD;
- struct sockaddr_dn sdn;
- struct hostent *hp;
-
- enterprocedure("ConnectToServer");
-
- /* establish a socket to the name server for this host */
- ServerFD = socket(AF_DECnet, SOCK_STREAM, 0);
- if (ServerFD < 0)
- {
- perror("socket() to Server failed");
- debug(1,(stderr, "socket failed\n"));
- panic("Can't open connection to Server");
- }
- (void) setsockopt(ServerFD, SOL_SOCKET, SO_REUSEADDR, (char *) NULL, 0);
- (void) setsockopt(ServerFD, SOL_SOCKET, SO_USELOOPBACK,(char *) NULL, 0);
- /* determine the host machine for this process */
- initialize_libdni();
- if (ServerHostName[0] == '\0')
- (dnet_gethostname)(ServerHostName);
- debug(4,(stderr, "try to connect on %s\n", ServerHostName));
-
- hp = (struct hostent *)(dnet_gethostbyname)(ServerHostName);
- if (hp == 0)
- {
- perror("gethostbyname failed");
- debug(1,(stderr, "gethostbyname failed for %s\n", ServerHostName));
- panic("Can't open connection to Server");
- }
-
- sdn.sdn_family = AF_DECnet;
- sdn.sdn_format = DNADDR_FMT1;
- sdn.sdn_port = 0;
- sprintf (sdn.sdn_name, "X$X%d", GetServerport() );
- sdn.sdn_namelen = strlen(sdn.sdn_name);
- sdn.sdn_addr = *(u_short *)hp->h_addr_list[0];
-
- /* ******************************************************** */
- /* try to connect to Server */
-
- if (connect(ServerFD, (struct sockaddr *)&sdn, sizeof(sdn)) < 0)
- {
- debug(4,(stderr, "connect returns errno of %d\n", errno));
- if (errno != 0)
- if (report)
- perror("connect");
- switch (errno)
- {
- case ECONNREFUSED:
- /* experience says this is because there is no Server
- to connect to */
- close(ServerFD);
- debug(1,(stderr, "No Server\n"));
- if (report)
- warn("Can't open connection to Server");
- return(-1);
-
- default:
- close(ServerFD);
- panic("Can't open connection to Server");
- }
- }
-
- debug(4,(stderr, "Connect To Server: FD %d\n", ServerFD));
- if (ServerFD >= 0)
- {
- UsingFD(ServerFD, DataFromServer, NULL);
- StartServerConnection(ServerFD);
- }
- return(ServerFD);
-}
-#endif
-
-/* ********************************************** */
-/* */
-/* ********************************************** */
-
-#ifdef DNETCONN
-FD ConnectToDECnetClient(fd)
- FD fd;
-{
- struct ses_io_type sesopts;
- static SessionData sd= {0, {0, ""}};
-
- if (ioctl(fd, SES_ACCEPT, &sd) < 0) {
- fprintf(stderr,"xscope: dni: SES_ACCEPT failed\n");
- exit(-1);
- }
- UsingFD(fd, DataFromClient, NULL);
- StartClientConnection(fd);
- /* unlike sockets, dni consumes the fd on which it was listening */
- /* in order to accept new logical link requests using the same name */
- /* we must re-open the logical link device and re-supply the */
- /* appropriate access control information */
-
- SetUpDECnetConnection(GetScopePort());
-
- return(fd);
-}
-
-
-FD ConnectToDECnetServer(report)
- Boolean report;
-{
- FD fd;
- OpenBlock opblk;
- struct ses_io_type sesopts;
- struct nodeent *np;
-
- if ((fd = open("/dev/dni", O_RDWR)) < 0) {
- fprintf(stderr,"xscope: dni: open failed\n");
- exit(-1);
- }
- if (ioctl(fd, SES_GET_LINK, 0)) {
- fprintf(stderr,"xscope: dni: can't get link\n");
- exit(-1);
- }
-
- /* set nonblocking here since dni can't handle fcntls */
- sesopts.io_flags = SES_IO_NBIO;
- sesopts.io_io_signal = sesopts.io_int_signal = 0;
-
- if (ioctl(fd, SES_IO_TYPE, &sesopts) < 0) {
- fprintf(stderr,"xscope: dni: ioctl failed\n");
- exit(-1);
- }
-
- strncpy(opblk.op_node_name,ServerHostName , 6); /* dni server name */
- opblk.op_node_name[6] = '\0';
- sprintf(opblk.op_task_name, "X$X%d", GetServerport());
- opblk.op_userid[0] = '\0'; /* No one checks our id */
- opblk.op_object_nbr = 0; /* Any fields not used */
- opblk.op_account[0] = '\0'; /* should be set to zero */
- opblk.op_password[0] = '\0';
- opblk.op_opt_data.im_length = 0;
-
- if (ioctl(fd, SES_LINK_ACCESS, &opblk) == -1) {
- fprintf(stderr,"xscope: dni: cannot connect to server\n");
- exit(-1);
- }
- UsingFD(fd, DataFromServer, NULL);
- StartServerConnection(fd);
- return(fd);
-
-}
-#endif
-
diff --git a/scope.h b/scope.h
index cec14b2..3100559 100644
--- a/scope.h
+++ b/scope.h
@@ -53,7 +53,16 @@
*
********************************************** */
+#ifndef XSCOPE_SCOPE_H
+#define XSCOPE_SCOPE_H
+
+#include <X11/Xos.h>
+#include <X11/Xfuncs.h>
#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <sys/param.h>
#ifdef SVR4
#include <sys/filio.h>
#endif /* SVR4 */
@@ -62,39 +71,37 @@
#define true 1
#define false 0
+#include "fd.h"
+
/* ********************************************** */
/* */
/* ********************************************** */
#define Assert(b) (b)
#define debug(n,f) (void)((debuglevel & n) ? (fprintf f,fflush(stderr)) : 0)
-short debuglevel;
+extern short debuglevel;
/* ********************************************** */
/* */
/* ********************************************** */
-short Verbose /* quiet (0) or increasingly verbose ( > 0) */ ;
+extern short Verbose /* quiet (0) or increasingly verbose ( > 0) */ ;
+extern short XVerbose;
+extern short NasVerbose;
#ifdef RAW_MODE
-short Raw /* raw data output only */ ;
+extern short Raw /* raw data output only */ ;
#else
#define Raw 0
#endif
-int ScopePort;
-char *ScopeHost;
-/* external function type declarations */
+extern int ScopePort;
+extern char *ScopeHost;
-extern void *Malloc (long n);
-#ifdef X_NOT_STDC_ENV
-extern char *strcpy();
-extern char *sprintf();
-#else
-#include <stdlib.h>
-#include <string.h>
-#endif
-extern char *ClientName();
+extern int Interrupt, SingleStep, BreakPoint;
+
+extern char ServerHostName[MAXHOSTNAMELEN];
+extern char AudioServerHostName[MAXHOSTNAMELEN];
/* ********************************************** */
/* */
@@ -102,3 +109,29 @@ extern char *ClientName();
#include "fd.h"
#include "proto.h"
+
+#define BUFFER_SIZE (1024 * 32)
+
+struct fdinfo
+{
+ Boolean Server;
+ long ClientNumber;
+ FD pair;
+ unsigned char buffer[BUFFER_SIZE];
+ int bufcount;
+ int bufstart;
+ int buflimit; /* limited writes */
+ int bufdelivered; /* total bytes delivered */
+ Boolean writeblocked;
+};
+
+extern struct fdinfo FDinfo[StaticMaxFD];
+extern int littleEndian;
+extern char HandleSIGUSR1;
+extern char Leader[];
+extern long ServerBasePort;
+extern char ScopeEnabled;
+extern long TranslateText;
+
+
+#endif /* XSCOPE_SCOPE_H */
diff --git a/server.c b/server.c
index 076648d..d04c335 100644
--- a/server.c
+++ b/server.c
@@ -61,7 +61,10 @@
#define bcopy(s,d,l) memmove(d,s,l)
#endif
-static void ProcessBuffer(FD fd, unsigned char *buf, long n);
+struct TypeDef TD[MaxTypes];
+unsigned char RBf[2];
+unsigned char SBf[4];
+struct ConnState CS[StaticMaxFD];
/* ************************************************************ */
/* */
@@ -69,27 +72,36 @@ static void ProcessBuffer(FD fd, unsigned char *buf, long n);
/* ************************************************************ */
void
-ReportFromClient(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+ReportFromClient(
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- PrintTime();
- fprintf(stdout, "Client%s --> %4d %s\n",
- ClientName(fd), n, (n == 1 ? "byte" : "bytes"));
- ProcessBuffer(fd, buf, n);
+ if (Verbose > 0)
+ {
+ if (ScopeEnabled) {
+ PrintTime();
+ fprintf(stdout, "Client%s --> %4ld %s\n",
+ ClientName(fd), n, (n == 1 ? "byte" : "bytes"));
+ }
+ }
+ ProcessBuffer(fd, buf, n);
}
void
-ReportFromServer(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+ReportFromServer (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- PrintTime();
- fprintf(stdout, "\t\t\t\t\t%4d %s <-- X11 Server%s\n",
- n, (n == 1 ? "byte" : "bytes"), ClientName(fd));
- ProcessBuffer(fd, buf, n);
+ if (Verbose > 0) {
+ if (ScopeEnabled) {
+ PrintTime();
+ fprintf(stdout, "\t\t\t\t\t%4ld %s <-- X11 Server%s\n",
+ n, (n == 1 ? "byte" : "bytes"), ClientName(fd));
+ }
+ }
+ ProcessBuffer(fd, buf, n);
}
@@ -98,7 +110,6 @@ ReportFromServer(fd, buf, n)
/* */
/* ************************************************************ */
-#include <sys/time.h> /* for struct timeval * */
static long ZeroTime1 = -1;
static long ZeroTime2 = -1;
static struct timeval tp;
@@ -106,7 +117,7 @@ static struct timeval tp;
/* print the time since we started in hundredths (1/100) of seconds */
void
-PrintTime()
+PrintTime(void)
{
static long lastsec = 0;
long sec /* seconds */ ;
@@ -127,7 +138,7 @@ PrintTime()
hsec += 100;
sec -= 1;
}
- fprintf(stdout, "%2d.%02ld: ", sec, hsec);
+ fprintf(stdout, "%2ld.%02ld: ", sec, hsec);
}
/* ************************************************************ */
@@ -139,39 +150,52 @@ PrintTime()
requests as various built-in types. The following routines
support the types built into X11 */
-long pad (n)
- long n;
+long
+pad (
+ long n)
{
/* round up to next multiple of 4 */
return((n + 3) & ~0x3);
}
-static int littleEndian;
-
-unsigned long ILong (buf)
- unsigned char buf[];
+unsigned long
+ILong (
+ const unsigned char buf[])
{
+ /* check for byte-swapping */
if (littleEndian)
return((((((buf[3] << 8) | buf[2]) << 8) | buf[1]) << 8) | buf[0]);
return((((((buf[0] << 8) | buf[1]) << 8) | buf[2]) << 8) | buf[3]);
}
-unsigned short IShort (buf)
-unsigned char buf[];
+unsigned short
+IShort (
+ const unsigned char buf[])
{
+ /* check for byte-swapping */
if (littleEndian)
return (buf[1] << 8) | buf[0];
return((buf[0] << 8) | buf[1]);
}
-unsigned short IByte (buf)
-unsigned char buf[];
+unsigned short
+IChar2B (
+ const unsigned char buf[])
+{
+ /* CHAR2B is like an IShort, but not byte-swapped */
+ return((buf[0] << 8) | buf[1]);
+}
+
+unsigned short
+IByte (
+ const unsigned char buf[])
{
return(buf[0]);
}
-Boolean IBool(buf)
- unsigned char buf[];
+Boolean
+IBool (
+ const unsigned char buf[])
{
if (buf[0] != 0)
return(true);
@@ -189,10 +213,10 @@ Boolean IBool(buf)
interpret. The following procedures provide this ability */
static void
-SaveBytes(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+SaveBytes (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
/* check if there is enough space to hold the bytes we want */
if (CS[fd].NumberofSavedBytes + n > CS[fd].SizeofSavedBytes)
@@ -216,9 +240,9 @@ SaveBytes(fd, buf, n)
}
static void
-RemoveSavedBytes(fd, n)
- FD fd;
- long n;
+RemoveSavedBytes (
+ FD fd,
+ long n)
{
/* check if all bytes are being removed -- easiest case */
if (CS[fd].NumberofSavedBytes <= n)
@@ -246,15 +270,13 @@ RemoveSavedBytes(fd, n)
/* following are the possible values for ByteProcessing */
/* forward declarations */
-static long StartSetUpMessage(FD fd, unsigned char *buf, long n);
-static long FinishSetUpMessage(FD fd, unsigned char *buf, long n);
-static long StartRequest(FD fd, unsigned char *buf, long n);
-static long FinishRequest(FD fd, unsigned char *buf, long n);
+static long FinishSetUpMessage(FD fd, const unsigned char *buf, long n);
+static long StartRequest(FD fd, const unsigned char *buf, long n);
+static long FinishRequest(FD fd, const unsigned char *buf, long n);
-static long StartSetUpReply(FD fd, unsigned char *buf, long n);
-static long FinishSetUpReply(FD fd, unsigned char *buf, long n);
-static long ServerPacket(FD fd, unsigned char *buf, long n);
-static long FinishReply(FD fd, unsigned char *buf, long n);
+static long FinishSetUpReply(FD fd, const unsigned char *buf, long n);
+static long ServerPacket(FD fd, const unsigned char *buf, long n);
+static long FinishReply(FD fd, const unsigned char *buf, long n);
/* ************************************************************ */
@@ -262,18 +284,24 @@ static long FinishReply(FD fd, unsigned char *buf, long n);
/* */
/* ************************************************************ */
-static void
-ProcessBuffer(fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+int littleEndian;
+
+void
+ProcessBuffer (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- unsigned char *BytesToProcess;
+ const unsigned char *BytesToProcess;
long NumberofUsedBytes;
/* as long as we have enough bytes to do anything -- do it */
- littleEndian = CS[fd].littleEndian;
+ if (Verbose > 4)
+ {
+ fprintf (stdout, "\nRead from fd %d\n", fd);
+ DumpHexBuffer (buf, n);
+ }
while (CS[fd].NumberofSavedBytes + n >= CS[fd].NumberofBytesNeeded)
{
/*
@@ -323,6 +351,7 @@ ProcessBuffer(fd, buf, n)
the state we are in. The processing routine should return the
number of bytes that it actually used.
*/
+ littleEndian = CS[fd].littleEndian;
NumberofUsedBytes = (*CS[fd].ByteProcessing)
(fd, BytesToProcess, CS[fd].NumberofBytesNeeded);
@@ -333,6 +362,7 @@ ProcessBuffer(fd, buf, n)
if (NumberofUsedBytes > 0)
{
+ CS[fd].NumberofBytesProcessed += NumberofUsedBytes;
if (CS[fd].NumberofSavedBytes > 0)
RemoveSavedBytes(fd, NumberofUsedBytes);
else
@@ -345,9 +375,15 @@ ProcessBuffer(fd, buf, n)
}
} /* end of while (NumberofSavedBytes + n >= NumberofBytesNeeded) */
+ if (Verbose > 3)
+ fprintf (stdout, "Have %ld need %ld\n",
+ CS[fd].NumberofSavedBytes + n,
+ CS[fd].NumberofBytesNeeded);
/* not enough bytes -- just save the new bytes for more later */
if (n > 0)
+ {
SaveBytes(fd, buf, n);
+ }
return;
}
@@ -363,14 +399,68 @@ ProcessBuffer(fd, buf, n)
*/
void
-StartClientConnection(fd)
- FD fd;
+SetBufLimit (
+ FD fd)
+{
+ int ServerFD = FDPair (fd);
+ FDinfo[ServerFD].buflimit = (CS[fd].NumberofBytesProcessed +
+ CS[fd].NumberofBytesNeeded);
+}
+
+void
+ClearBufLimit (
+ FD fd)
+{
+ int ServerFD = FDPair (fd);
+ FDinfo[ServerFD].buflimit = -1;
+}
+
+static void
+StartStuff (
+ FD fd)
+{
+ if (BreakPoint)
+ {
+ int ServerFD = FDPair (fd);
+ FDinfo[ServerFD].buflimit = (CS[fd].NumberofBytesProcessed +
+ CS[fd].NumberofBytesNeeded);
+ FlushFD (ServerFD);
+ }
+}
+
+static void
+FinishStuff (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ if (BreakPoint)
+ {
+ int ServerFD = FDPair (fd);
+
+ FlushFD (ServerFD);
+ if (SingleStep)
+ ReadCommands ();
+ else if (BreakPoint)
+ TestBreakPoints (buf, n);
+ if (!BreakPoint)
+ {
+ FDinfo[ServerFD].buflimit = -1;
+ FlushFD (ServerFD);
+ }
+ }
+}
+
+void
+StartClientConnection (
+ FD fd)
{
enterprocedure("StartClientConnection");
/* when a new connection is started, we have no saved bytes */
CS[fd].SavedBytes = NULL;
CS[fd].SizeofSavedBytes = 0;
CS[fd].NumberofSavedBytes = 0;
+ CS[fd].NumberofBytesProcessed = 0;
/* when a new connection is started, we have no reply Queue */
FlushReplyQ(fd);
@@ -381,11 +471,12 @@ StartClientConnection(fd)
/* we need 12 bytes to start a SetUp message */
CS[fd].ByteProcessing = StartSetUpMessage;
CS[fd].NumberofBytesNeeded = 12;
+ StartStuff (fd);
}
void
-StopClientConnection(fd)
- FD fd;
+StopClientConnection (
+ FD fd)
{
enterprocedure("StopClientConnection");
/* when a new connection is stopped, discard the old buffer */
@@ -394,10 +485,11 @@ StopClientConnection(fd)
Free((char*)CS[fd].SavedBytes);
}
-static long StartSetUpMessage (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+long
+StartSetUpMessage (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
unsigned short namelength;
unsigned short datalength;
@@ -409,21 +501,26 @@ static long StartSetUpMessage (fd, buf, n)
can't process the first 12 bytes until we get all of them, so
return zero bytes used, and increase the number of bytes needed
*/
-
+ CS[fd].littleEndian = (buf[0] == 'l');
+ CS[ServerHalf(fd)].littleEndian = CS[fd].littleEndian;
+ littleEndian = CS[fd].littleEndian;
+
namelength = IShort(&buf[6]);
datalength = IShort(&buf[8]);
CS[fd].ByteProcessing = FinishSetUpMessage;
CS[fd].NumberofBytesNeeded = n
+ pad((long)namelength) + pad((long)datalength);
- debug(8,(stderr, "need %d bytes to finish startup\n",
+ debug(8,(stderr, "need %ld bytes to finish startup\n",
CS[fd].NumberofBytesNeeded - n));
+ StartStuff (fd);
return(0);
}
-static long FinishSetUpMessage (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+static long
+FinishSetUpMessage (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
enterprocedure("FinishSetUpMessage");
if( Raw || (Verbose > 3) )
@@ -431,43 +528,76 @@ static long FinishSetUpMessage (fd, buf, n)
CS[fd].littleEndian = (buf[0] == 'l');
CS[ServerHalf(fd)].littleEndian = CS[fd].littleEndian;
littleEndian = CS[fd].littleEndian;
- PrintSetUpMessage(buf);
+ if (ScopeEnabled)
+ PrintSetUpMessage(buf);
/* after a set-up message, we expect a string of requests */
CS[fd].ByteProcessing = StartRequest;
CS[fd].NumberofBytesNeeded = 4;
+ FinishStuff (fd, buf, n);
return(n);
}
-
-static long StartRequest (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+static long
+StartBigRequest (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- unsigned short requestlength;
- enterprocedure("StartRequest");
+ enterprocedure("StartBigRequest");
- /* bytes 0,1 are ignored now; bytes 2,3 tell us the request length */
- requestlength = IShort(&buf[2]);
+ /* bytes 0-3 are ignored now; bytes 4-8 tell us the request length */
+ CS[fd].requestLen = ILong(&buf[4]);
CS[fd].ByteProcessing = FinishRequest;
- CS[fd].NumberofBytesNeeded = 4 * requestlength;
- debug(8,(stderr, "need %d more bytes to finish request\n",
+ CS[fd].NumberofBytesNeeded = 4 * CS[fd].requestLen;
+ debug(8,(stderr, "need %ld more bytes to finish request\n",
CS[fd].NumberofBytesNeeded - n));
+ StartStuff (fd);
return(0);
}
+static long
+StartRequest (
+ FD fd,
+ const unsigned char *buf,
+ long n)
+{
+ enterprocedure("StartRequest");
-static long FinishRequest (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+ /* bytes 0,1 are ignored now; bytes 2,3 tell us the request length */
+ CS[fd].requestLen = IShort(&buf[2]);
+ if (CS[fd].requestLen == 0 && CS[fd].bigreqEnabled)
+ {
+ CS[fd].ByteProcessing = StartBigRequest;
+ CS[fd].NumberofBytesNeeded = 8;
+ }
+ else
+ {
+ if (CS[fd].requestLen == 0)
+ CS[fd].requestLen = 1;
+ CS[fd].ByteProcessing = FinishRequest;
+ CS[fd].NumberofBytesNeeded = 4 * CS[fd].requestLen;
+ debug(8,(stderr, "need %ld more bytes to finish request\n",
+ CS[fd].NumberofBytesNeeded - n));
+ }
+ StartStuff (fd);
+ return(0);
+}
+
+
+static long
+FinishRequest (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
enterprocedure("FinishRequest");
- DecodeRequest(fd, buf, n);
CS[fd].ByteProcessing = StartRequest;
CS[fd].NumberofBytesNeeded = 4;
+ if (ScopeEnabled)
+ DecodeRequest(fd, buf, n);
+ FinishStuff (fd, buf, n);
return(n);
}
@@ -477,14 +607,15 @@ static long FinishRequest (fd, buf, n)
/* ************************************************************ */
void
-StartServerConnection(fd)
- FD fd;
+StartServerConnection (
+ FD fd)
{
enterprocedure("StartServerConnection");
/* when a new connection is started, we have no saved bytes */
CS[fd].SavedBytes = NULL;
CS[fd].SizeofSavedBytes = 0;
CS[fd].NumberofSavedBytes = 0;
+ CS[fd].NumberofBytesProcessed = 0;
/* when a new connection is started, we have no reply Queue */
FlushReplyQ(fd);
@@ -495,8 +626,8 @@ StartServerConnection(fd)
}
void
-StopServerConnection(fd)
- FD fd;
+StopServerConnection (
+ FD fd)
{
enterprocedure("StopServerConnection");
/* when a new connection is stopped, discard the old buffer */
@@ -505,11 +636,11 @@ StopServerConnection(fd)
Free((char *)CS[fd].SavedBytes);
}
-static long
-StartSetUpReply (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+long
+StartSetUpReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
unsigned short replylength;
@@ -517,21 +648,22 @@ StartSetUpReply (fd, buf, n)
replylength = IShort(&buf[6]);
CS[fd].ByteProcessing = FinishSetUpReply;
CS[fd].NumberofBytesNeeded = n + 4 * replylength;
- debug(8,(stderr, "need %d bytes to finish startup reply\n",
+ debug(8,(stderr, "need %ld bytes to finish startup reply\n",
CS[fd].NumberofBytesNeeded - n));
return(0);
}
static long
-FinishSetUpReply (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+FinishSetUpReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
enterprocedure("FinishSetUpReply");
if( Raw || (Verbose > 3) )
DumpItem("Server Connect", fd, buf, n) ;
- PrintSetUpReply(buf);
+ if (ScopeEnabled)
+ PrintSetUpReply(buf);
CS[fd].ByteProcessing = ServerPacket;
CS[fd].NumberofBytesNeeded = 32;
return(n);
@@ -540,44 +672,38 @@ FinishSetUpReply (fd, buf, n)
/* ************************************************************ */
static long
-ErrorPacket (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+ErrorPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- fprintf(stdout, "Error: ");
- DecodeError(fd, buf, n);
CS[fd].ByteProcessing = ServerPacket;
CS[fd].NumberofBytesNeeded = 32;
+ DecodeError(fd, buf, n);
return(n);
}
static long
-EventPacket (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+EventPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- DecodeEvent(fd, buf, n);
CS[fd].ByteProcessing = ServerPacket;
CS[fd].NumberofBytesNeeded = 32;
+ if (ScopeEnabled)
+ DecodeEvent(fd, buf, n);
return(n);
}
static long
-ReplyPacket (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+ReplyPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- /*
- B U G: 4242329
- fix for GetImage packet, where data length is too long
- to handle using a short field.
- */
-
long replylength;
replylength = ILong(&buf[4]);
@@ -594,15 +720,15 @@ ReplyPacket (fd, buf, n)
CS[fd].ByteProcessing = FinishReply;
CS[fd].NumberofBytesNeeded = n + 4 * replylength;
- debug(8,(stderr, "need %d bytes to finish reply\n", (4 * replylength)));
+ debug(8,(stderr, "need %ld bytes to finish reply\n", (4 * replylength)));
return(0);
}
static long
-ServerPacket (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+ServerPacket (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
short PacketType;
enterprocedure("ServerPacket");
@@ -615,14 +741,23 @@ ServerPacket (fd, buf, n)
return(EventPacket(fd, buf, n));
}
-long FinishReply (fd, buf, n)
- FD fd;
- unsigned char *buf;
- long n;
+long
+FinishReply (
+ FD fd,
+ const unsigned char *buf,
+ long n)
{
- enterprocedure("FinishReply");
- DecodeReply(fd, buf, n);
CS[fd].ByteProcessing = ServerPacket;
CS[fd].NumberofBytesNeeded = 32;
+ enterprocedure("FinishReply");
+ if (ScopeEnabled)
+ DecodeReply(fd, buf, n);
return(n);
}
+
+long
+GetXRequestFromName (
+ const char *name)
+{
+ return GetEValue (REQUEST, name);
+}
diff --git a/shmscope.h b/shmscope.h
new file mode 100644
index 0000000..6d56f4c
--- /dev/null
+++ b/shmscope.h
@@ -0,0 +1,30 @@
+#ifndef _MITSHMSCOPE_H_
+#define _MITSHMSCOPE_H_
+
+#define MITSHMREQUESTHEADER "MITSHMREQUEST"
+#define MITSHMREPLYHEADER "MITSHMREPLY"
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
+
+extern unsigned char MITSHMRequest;
+extern unsigned char MITSHMError;
+extern unsigned char MITSHMEvent;
+
+extern void MitshmQueryVersion (FD fd, const unsigned char *buf);
+extern void MitshmQueryVersionReply (FD fd, const unsigned char *buf);
+extern void MitshmAttach (FD fd, const unsigned char *buf);
+extern void MitshmDetach (FD fd, const unsigned char *buf);
+extern void MitshmPutImage (FD fd, const unsigned char *buf);
+extern void MitshmGetImage (FD fd, const unsigned char *buf);
+extern void MitshmGetImageReply (FD fd, const unsigned char *buf);
+extern void MitshmCreatePixmap (FD fd, const unsigned char *buf);
+extern void MitshmShmSegError (FD fd, const unsigned char *buf);
+
+#endif
+
diff --git a/table11.c b/table11.c
index eaac5af..56fe988 100644
--- a/table11.c
+++ b/table11.c
@@ -66,21 +66,21 @@ static void InitSetTypes(void);
static void InitRecordTypes(void);
static void InitValuesTypes(void);
-static int PrintCHAR2B(unsigned char *buf);
-static int PrintPOINT(unsigned char *buf);
-static int PrintRECTANGLE(unsigned char *buf);
-static int PrintARC(unsigned char *buf);
-static int PrintHOST(unsigned char *buf);
-static int PrintTIMECOORD(unsigned char *buf);
-static int PrintFONTPROP(unsigned char *buf);
-static int PrintCHARINFO(unsigned char *buf);
-static int PrintSEGMENT(unsigned char *buf);
-static int PrintCOLORITEM(unsigned char *buf);
-static int PrintRGB(unsigned char *buf);
-static int PrintFORMAT(unsigned char *buf);
-static int PrintSCREEN(unsigned char *buf);
-static int PrintDEPTH(unsigned char *buf);
-static int PrintVISUALTYPE(unsigned char *buf);
+static int PrintCHAR2B(const unsigned char *buf);
+static int PrintPOINT(const unsigned char *buf);
+static int PrintRECTANGLE(const unsigned char *buf);
+static int PrintARC(const unsigned char *buf);
+static int PrintHOST(const unsigned char *buf);
+static int PrintTIMECOORD(const unsigned char *buf);
+static int PrintFONTPROP(const unsigned char *buf);
+static int PrintCHARINFO(const unsigned char *buf);
+static int PrintSEGMENT(const unsigned char *buf);
+static int PrintCOLORITEM(const unsigned char *buf);
+static int PrintRGB(const unsigned char *buf);
+static int PrintFORMAT(const unsigned char *buf);
+static int PrintSCREEN(const unsigned char *buf);
+static int PrintDEPTH(const unsigned char *buf);
+static int PrintVISUALTYPE(const unsigned char *buf);
/*
To initialize for the X11 protocol, we need to create data structures
@@ -111,7 +111,7 @@ static int PrintVISUALTYPE(unsigned char *buf);
*/
void
-InitializeX11()
+InitializeX11 (void)
{
InitReplyQ();
@@ -122,6 +122,105 @@ InitializeX11()
InitRecordTypes();
}
+#define HASH_SIZE 997
+
+ValuePtr buckets[HASH_SIZE];
+
+#define HASH(key) ((key) % HASH_SIZE)
+
+ValuePtr
+GetValueRec (
+ unsigned long key)
+{
+ ValuePtr *bucket, value;
+
+ bucket = &buckets[HASH(key)];
+ for (value = *bucket; value; value = value->next)
+ {
+ if (value->key == key)
+ return value;
+ }
+ return NULL;
+}
+
+void
+CreateValueRec (
+ unsigned long key,
+ int size,
+ const unsigned long *def)
+{
+ ValuePtr *bucket, value;
+ int i;
+
+ bucket = &buckets[HASH(key)];
+ value = (ValuePtr) malloc (sizeof (ValueRec) + size * sizeof (unsigned long));
+ if (!value)
+ return;
+ value->values = (unsigned long *) (value + 1);
+ for (i = 0; i < size; i++)
+ value->values[i] = ILong((const unsigned char *) (def + i));
+ value->size = size;
+ value->key = key;
+ value->next = *bucket;
+ *bucket = value;
+}
+
+void
+DeleteValueRec (
+ unsigned long key)
+{
+ ValuePtr *bucket, value;
+
+ for (bucket = &buckets[HASH(key)]; value = *bucket; bucket = &value->next)
+ {
+ if (value->key == key)
+ {
+ *bucket = value->next;
+ free (value);
+ return;
+ }
+ }
+}
+
+void
+SetValueRec (
+ unsigned long key,
+ const unsigned char *control,
+ short clength,
+ short ctype,
+ const unsigned char *values)
+{
+ long cmask;
+ struct ValueListEntry *p;
+ ValuePtr value;
+ int i;
+
+ value = GetValueRec (key);
+ if (!value)
+ return;
+ /* first get the control mask */
+ if (clength == 1)
+ cmask = IByte(control);
+ else if (clength == 2)
+ cmask = IShort(control);
+ else
+ cmask = ILong(control);
+
+ /* now if it is zero, ignore and return */
+ if (cmask == 0)
+ return;
+ /* there are bits in the controlling bitmask, figure out which */
+ /* the ctype is a set type, so this code is similar to PrintSET */
+ for (p = TD[ctype].ValueList, i = 0; p != NULL; p = p->Next, i++)
+ {
+ if ((p->Value & cmask) != 0)
+ {
+ memcpy (&value->values[i], values, sizeof (unsigned long));
+ values += 4;
+ }
+ }
+}
+
/* ************************************************************ */
/* */
/* */
@@ -129,12 +228,12 @@ InitializeX11()
/* define the various types */
-static TYPE
-DefineType(typeid, class, name, printproc)
- short typeid;
- short class;
- char *name;
- int (*printproc)(unsigned char *);
+TYPE
+DefineType (
+ short typeid,
+ short class,
+ const char *name,
+ int (*printproc)(const unsigned char *))
{
TD[typeid].Name = name;
TD[typeid].Type = class;
@@ -146,11 +245,11 @@ DefineType(typeid, class, name, printproc)
/* ************************************************************ */
/* define an Enumerated Value (or a Set Value) */
-static void
-DefineEValue(type, value, name)
- TYPE type;
- long value;
- char *name;
+void
+DefineEValue(
+ TYPE type,
+ long value,
+ const char *name)
{
struct ValueListEntry *p;
@@ -177,6 +276,25 @@ DefineEValue(type, value, name)
}
}
+long
+GetEValue (
+ short typeid,
+ const char *name)
+{
+ TYPE p;
+ struct ValueListEntry *v;
+
+ if (typeid < 0 || MaxTypes <= typeid)
+ return -1;
+ p = &TD[typeid];
+ if (!p)
+ return -2;
+ for (v = p->ValueList; v; v = v->Next)
+ if (!strcmp (name, v->Name))
+ return v->Value;
+ return -3;
+}
+
/* ************************************************************ */
/* a Values list is like an enumerated Value, but has a type and length
in addition to a value and name. It is used to print a Values List */
@@ -185,8 +303,9 @@ DefineEValue(type, value, name)
we have an associated value. We need to know the length and type of the
associated value for each bit */
-static void
-DefineValues(TYPE type, long value, short length, short ctype, char *name)
+void
+DefineValues(TYPE type, long value, short length, short ctype,
+ const char *name)
{
struct ValueListEntry *p;
@@ -219,7 +338,7 @@ DefineValues(TYPE type, long value, short length, short ctype, char *name)
/* ************************************************************ */
static void
-InitBuiltInTypes()
+InitBuiltInTypes (void)
{
(void) DefineType(INT8, BUILTIN, "INT8", PrintINT8);
(void) DefineType(INT16, BUILTIN, "INT16", PrintINT16);
@@ -264,7 +383,7 @@ InitBuiltInTypes()
/* ************************************************************ */
static void
-InitEnumeratedTypes()
+InitEnumeratedTypes (void)
{
TYPE p;
@@ -765,7 +884,7 @@ InitEnumeratedTypes()
/* ************************************************************ */
static void
-InitSetTypes()
+InitSetTypes (void)
{
TYPE p;
@@ -869,8 +988,8 @@ InitSetTypes()
/* Print Routines for builtin record types */
static int
-PrintCHAR2B(buf)
- unsigned char *buf;
+PrintCHAR2B (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, CARD8, "byte1");
PrintField(buf, 1, 1, CARD8, "byte2");
@@ -878,8 +997,8 @@ PrintCHAR2B(buf)
}
static int
-PrintPOINT(buf)
- unsigned char *buf;
+PrintPOINT (
+ const unsigned char *buf)
{
PrintField(buf, 0, 2, INT16, "x");
PrintField(buf, 2, 2, INT16, "y");
@@ -887,8 +1006,8 @@ PrintPOINT(buf)
}
static int
-PrintRECTANGLE(buf)
- unsigned char *buf;
+PrintRECTANGLE (
+ const unsigned char *buf)
{
PrintField(buf, 0, 2, INT16, "x");
PrintField(buf, 2, 2, INT16, "y");
@@ -898,8 +1017,8 @@ PrintRECTANGLE(buf)
}
static int
-PrintARC(buf)
- unsigned char *buf;
+PrintARC (
+ const unsigned char *buf)
{
PrintField(buf, 0, 2, INT16, "x");
PrintField(buf, 2, 2, INT16, "y");
@@ -911,8 +1030,8 @@ PrintARC(buf)
}
static int
-PrintHOST(buf)
- unsigned char *buf;
+PrintHOST (
+ const unsigned char *buf)
{
short n;
PrintField(buf, 0, 1, HOSTFAMILY, "family");
@@ -951,8 +1070,8 @@ PrintHOST(buf)
}
static int
-PrintTIMECOORD(buf)
- unsigned char *buf;
+PrintTIMECOORD (
+ const unsigned char *buf)
{
PrintField(buf, 0, 4, TIMESTAMP, "time");
PrintField(buf, 4, 2, CARD16, "x");
@@ -961,8 +1080,8 @@ PrintTIMECOORD(buf)
}
static int
-PrintFONTPROP(buf)
- unsigned char *buf;
+PrintFONTPROP (
+ const unsigned char *buf)
{
PrintField(buf, 0, 4, ATOM, "name");
PrintField(buf, 4, 4, INT32, "value");
@@ -970,8 +1089,8 @@ PrintFONTPROP(buf)
}
static int
-PrintCHARINFO(buf)
- unsigned char *buf;
+PrintCHARINFO (
+ const unsigned char *buf)
{
PrintField(buf, 0, 2, INT16, "left-side-bearing");
PrintField(buf, 2, 2, INT16, "right-side-bearing");
@@ -983,8 +1102,8 @@ PrintCHARINFO(buf)
}
static int
-PrintSEGMENT(buf)
- unsigned char *buf;
+PrintSEGMENT (
+ const unsigned char *buf)
{
PrintField(buf, 0, 2, INT16, "x1");
PrintField(buf, 2, 2, INT16, "y1");
@@ -994,8 +1113,8 @@ PrintSEGMENT(buf)
}
static int
-PrintCOLORITEM(buf)
- unsigned char *buf;
+PrintCOLORITEM (
+ const unsigned char *buf)
{
PrintField(buf, 0, 4, CARD32, "pixel");
PrintField(buf, 4, 2, CARD16, "red");
@@ -1006,8 +1125,8 @@ PrintCOLORITEM(buf)
}
static int
-PrintRGB(buf)
- unsigned char *buf;
+PrintRGB (
+ const unsigned char *buf)
{
PrintField(buf, 0, 2, CARD16, "red");
PrintField(buf, 2, 2, CARD16, "green");
@@ -1016,8 +1135,8 @@ PrintRGB(buf)
}
static int
-PrintFORMAT(buf)
- unsigned char *buf;
+PrintFORMAT (
+ const unsigned char *buf)
{
PrintField(buf, 0, 1, CARD8, "depth");
PrintField(buf, 1, 1, CARD8, "bits-per-pixel");
@@ -1026,8 +1145,8 @@ PrintFORMAT(buf)
}
static int
-PrintSCREEN(buf)
- unsigned char *buf;
+PrintSCREEN (
+ const unsigned char *buf)
{
short n /* number of elements in List of DEPTH */ ;
long m /* length (in bytes) of List of DEPTH */ ;
@@ -1054,8 +1173,8 @@ PrintSCREEN(buf)
}
static int
-PrintDEPTH(buf)
- unsigned char *buf;
+PrintDEPTH (
+ const unsigned char *buf)
{
short n /* number of elements in List of VISUALTYPE */ ;
short m /* length (in bytes) of List of VISUALTYPE */ ;
@@ -1068,8 +1187,8 @@ PrintDEPTH(buf)
}
static int
-PrintVISUALTYPE(buf)
- unsigned char *buf;
+PrintVISUALTYPE (
+ const unsigned char *buf)
{
PrintField(buf, 0, 4, VISUALID, "visual-id");
PrintField(buf, 4, 1, COLORCLASS, "class");
@@ -1084,7 +1203,7 @@ PrintVISUALTYPE(buf)
/* ************************************************************ */
static void
-InitRecordTypes()
+InitRecordTypes (void)
{
(void) DefineType(CHAR2B, RECORD, "CHAR2B", PrintCHAR2B);
(void) DefineType(POINT, RECORD, "POINT", PrintPOINT);
@@ -1111,7 +1230,7 @@ InitRecordTypes()
/* ************************************************************ */
static void
-InitValuesTypes()
+InitValuesTypes (void)
{
TYPE p;
diff --git a/tablenas.c b/tablenas.c
new file mode 100644
index 0000000..c6d354d
--- /dev/null
+++ b/tablenas.c
@@ -0,0 +1,29 @@
+/*
+ * $NCDOr$
+ *
+ * Copyright 1996 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+InitializeAudio ()
+{
+ ;
+}
diff --git a/wcpscope.h b/wcpscope.h
new file mode 100644
index 0000000..6556f6f
--- /dev/null
+++ b/wcpscope.h
@@ -0,0 +1,54 @@
+/*
+ * $NCDOr$
+ *
+ * Copyright 1996 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. NCD. makes no representations about the
+ * suitability of this software for any purpose. It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Keith Packard, Network Computing Devices
+ */
+
+#ifndef _WCPSCOPE_H_
+#define _WCPSCOPE_H_
+
+#define WCPREQUESTHEADER "WCPREQUEST"
+#define WCPREPLYHEADER "WCPREPLY"
+
+/*
+ To aid in making the choice between level 1 and level 2, we
+ define the following define, which does not print relatively
+ unimportant fields.
+*/
+
+#define printfield(a,b,c,d,e) if (Verbose > 1) PrintField(a,b,c,d,e)
+
+extern unsigned char WCPRequest;
+extern unsigned char WCPError;
+
+extern void WcpQueryVersion (FD fd, const unsigned char *buf);
+extern void WcpQueryVersionReply (FD fd, const unsigned char *buf);
+extern void WcpPutImage (FD fd, const unsigned char *buf);
+extern void WcpGetImage (FD fd, const unsigned char *buf);
+extern void WcpGetImageReply (FD fd, const unsigned char *buf);
+extern void WcpCreateColorCursor (FD fd, const unsigned char *buf);
+extern void WcpCreateLut (FD fd, const unsigned char *buf);
+extern void WcpFreeLut (FD fd, const unsigned char *buf);
+extern void WcpCopyArea (FD fd, const unsigned char *buf);
+
+#endif
+
diff --git a/x11.h b/x11.h
index 175250b..db5abe7 100644
--- a/x11.h
+++ b/x11.h
@@ -216,8 +216,51 @@
#define ERROR 119
#define EVENT 120
-#define MaxTypes 128
-
+#define LBXREQUEST 121
+#define LBXREPLY 122
+#define LBXEVENT 123
+#define LBXERROR 124
+
+#define NASREQUEST 125
+#define NASREPLY 126
+#define NASEVENT 127
+#define NASERROR 128
+
+#define WCPREQUEST 129
+#define WCPREPLY 130
+#define WCPERROR 131
+
+#define RENDERREQUEST 132
+#define RENDERREPLY 133
+#define RENDERERROR 134
+
+#define PICTURE 135
+#define PICTFORMAT 136
+#define PICTURE_BITMASK 137
+#define PICTOP 138
+#define GLYPHSET 139
+#define RENDERCOLOR 140
+#define PICTFORMINFO 141
+#define TRAPEZOID 142
+#define TRIANGLE 143
+#define POINTFIXED 144
+#define FIXED 145
+
+#define RANDRREQUEST 150
+#define RANDRREPLY 151
+#define RANDRERROR 152
+
+#define MITSHMREQUEST 153
+#define MITSHMREPLY 154
+#define MITSHMEVENT 155
+#define MITSHMERROR 156
+
+#define BIGREQREQUEST 157
+#define BIGREQREPLY 158
+
+#define MaxTypes 256
+
+extern char ScopeEnabled;
/* ************************************************************ */
/* */
@@ -247,17 +290,17 @@
struct ValueListEntry
{
struct ValueListEntry *Next;
- char *Name;
+ const char *Name;
short Type;
short Length;
long Value;
};
-typedef int (*PrintProcType) (unsigned char *);
+typedef int (*PrintProcType) (const unsigned char *);
struct TypeDef
{
- char *Name;
+ const char *Name;
short Type /* BUILTIN, ENUMERATED, SET, or RECORD */ ;
struct ValueListEntry *ValueList;
PrintProcType PrintProc;
@@ -265,7 +308,7 @@ struct TypeDef
typedef struct TypeDef *TYPE;
-struct TypeDef TD[MaxTypes];
+extern struct TypeDef TD[MaxTypes];
/* ************************************************************ */
/* */
@@ -274,45 +317,45 @@ struct TypeDef TD[MaxTypes];
/* declaration of the existance of print routines for the basic types */
-int PrintINT8(unsigned char *buf);
-int PrintINT16(unsigned char *buf);
-int PrintINT32(unsigned char *buf);
-int PrintCARD8(unsigned char *buf);
-int PrintCARD16(unsigned char *buf);
-int PrintCARD32(unsigned char *buf);
-int PrintBYTE(unsigned char *buf);
-int PrintCHAR8(unsigned char *buf);
-int PrintSTRING16(unsigned char *buf);
-int PrintTEXTITEM8(unsigned char *buf);
-int PrintTEXTITEM16(unsigned char *buf);
-int PrintSTR(unsigned char *buf);
-int PrintWINDOW(unsigned char *buf);
-int PrintWINDOWD(unsigned char *buf);
-int PrintWINDOWNR(unsigned char *buf);
-int PrintPIXMAP(unsigned char *buf);
-int PrintPIXMAPNPR(unsigned char *buf);
-int PrintPIXMAPC(unsigned char *buf);
-int PrintCURSOR(unsigned char *buf);
-int PrintFONT(unsigned char *buf);
-int PrintGCONTEXT(unsigned char *buf);
-int PrintCOLORMAP(unsigned char *buf);
-int PrintCOLORMAPC(unsigned char *buf);
-int PrintDRAWABLE(unsigned char *buf);
-int PrintFONTABLE(unsigned char *buf);
-int PrintATOM(unsigned char *buf);
-int PrintATOMT(unsigned char *buf);
-int PrintVISUALID(unsigned char *buf);
-int PrintVISUALIDC(unsigned char *buf);
-int PrintTIMESTAMP(unsigned char *buf);
-int PrintRESOURCEID(unsigned char *buf);
-int PrintKEYSYM(unsigned char *buf);
-int PrintKEYCODE(unsigned char *buf);
-int PrintKEYCODEA(unsigned char *buf);
-int PrintBUTTON(unsigned char *buf);
-int PrintBUTTONA(unsigned char *buf);
-int PrintEVENTFORM(unsigned char *buf);
-int PrintENUMERATED(unsigned char *buf, short length, struct ValueListEntry *ValueList);
-int PrintSET(unsigned char *buf, short length, struct ValueListEntry *ValueList);
+extern int PrintINT8(const unsigned char *buf);
+extern int PrintINT16(const unsigned char *buf);
+extern int PrintINT32(const unsigned char *buf);
+extern int PrintCARD8(const unsigned char *buf);
+extern int PrintCARD16(const unsigned char *buf);
+extern int PrintCARD32(const unsigned char *buf);
+extern int PrintBYTE(const unsigned char *buf);
+extern int PrintCHAR8(const unsigned char *buf);
+extern int PrintSTRING16(const unsigned char *buf);
+extern int PrintTEXTITEM8(const unsigned char *buf);
+extern int PrintTEXTITEM16(const unsigned char *buf);
+extern int PrintSTR(const unsigned char *buf);
+extern int PrintWINDOW(const unsigned char *buf);
+extern int PrintWINDOWD(const unsigned char *buf);
+extern int PrintWINDOWNR(const unsigned char *buf);
+extern int PrintPIXMAP(const unsigned char *buf);
+extern int PrintPIXMAPNPR(const unsigned char *buf);
+extern int PrintPIXMAPC(const unsigned char *buf);
+extern int PrintCURSOR(const unsigned char *buf);
+extern int PrintFONT(const unsigned char *buf);
+extern int PrintGCONTEXT(const unsigned char *buf);
+extern int PrintCOLORMAP(const unsigned char *buf);
+extern int PrintCOLORMAPC(const unsigned char *buf);
+extern int PrintDRAWABLE(const unsigned char *buf);
+extern int PrintFONTABLE(const unsigned char *buf);
+extern int PrintATOM(const unsigned char *buf);
+extern int PrintATOMT(const unsigned char *buf);
+extern int PrintVISUALID(const unsigned char *buf);
+extern int PrintVISUALIDC(const unsigned char *buf);
+extern int PrintTIMESTAMP(const unsigned char *buf);
+extern int PrintRESOURCEID(const unsigned char *buf);
+extern int PrintKEYSYM(const unsigned char *buf);
+extern int PrintKEYCODE(const unsigned char *buf);
+extern int PrintKEYCODEA(const unsigned char *buf);
+extern int PrintBUTTON(const unsigned char *buf);
+extern int PrintBUTTONA(const unsigned char *buf);
+extern int PrintEVENTFORM(const unsigned char *buf);
+extern int PrintENUMERATED(const unsigned char *buf, short length, struct ValueListEntry *ValueList);
+extern int PrintSET(const unsigned char *buf, short length, struct ValueListEntry *ValueList);
/* ************************************************************ */
/* */
@@ -322,13 +365,13 @@ int PrintSET(unsigned char *buf, short length, struct ValueListEntry *ValueList)
/* Reply Buffer: Pseudo-buffer used to provide the opcode for the
request to which this is a reply: Set by DecodeReply
and used in the PrintField of the Reply procedure */
-unsigned char RBf[2];
+extern unsigned char RBf[2];
/* Sequence Buffer: Pseudo-buffer used to provide the sequence number for a
request: Set by DecodeReply and used in a PrintField of
the Request procedure */
-unsigned char SBf[4];
+extern unsigned char SBf[4];
#define PRINTSERVER 5 /* indent output as if it comes from server */
@@ -449,35 +492,101 @@ unsigned char SBf[4];
struct ConnState
{
unsigned char *SavedBytes;
- int littleEndian;
+ int littleEndian;
+ int bigreqEnabled;
+ long requestLen;
long SizeofSavedBytes;
long NumberofSavedBytes;
long NumberofBytesNeeded;
- long (*ByteProcessing)();
+ long NumberofBytesProcessed;
+ long (*ByteProcessing)(FD fd, const unsigned char *buf, long n);
long SequenceNumber;
};
-struct ConnState CS[StaticMaxFD];
-
-
-
+extern struct ConnState CS[StaticMaxFD];
+
+typedef struct _Value {
+ struct _Value *next;
+ unsigned long key;
+ int size;
+ unsigned long *values;
+} ValueRec, *ValuePtr;
+
+extern ValuePtr GetValueRec (unsigned long key);
+extern void CreateValueRec (unsigned long key, int size,
+ const unsigned long *def);
+extern void DeleteValueRec (unsigned long key);
+extern void SetValueRec (unsigned long key, const unsigned char *control,
+ short clength, short ctype,
+ const unsigned char *values);
+extern void PrintValueRec (unsigned long key, unsigned long cmask,
+ short ctype);
/* ************************************************************ */
/* */
/* */
/* ************************************************************ */
-/* declaraction of the types of some common functions */
-
-extern unsigned long ILong();
-extern unsigned short IShort();
-extern unsigned short IByte();
-extern Boolean IBool();
-
-extern long PrintList();
-extern long PrintListSTR();
-extern long pad();
+/* declaration of the types of some common functions */
+
+extern unsigned long ILong(const unsigned char *buf);
+extern unsigned short IShort(const unsigned char *buf);
+extern unsigned short IChar2B(const unsigned char *buf);
+extern unsigned short IByte(const unsigned char *buf);
+extern Boolean IBool(const unsigned char *buf);
+
+extern int PrintString8(const unsigned char *buf, int number,
+ const char *name);
+extern int PrintString16(const unsigned char *buf, int number,
+ const char *name);
+extern void PrintTString8(const unsigned char *buf, long number,
+ const char *name);
+extern void PrintTString16(const unsigned char *buf, long number,
+ const char *name);
+
+extern long PrintList (const unsigned char *buf, long number, short ListType,
+ const char *name);
+extern long PrintListSTR (const unsigned char *buf, long number,
+ const char *name);
+
+extern long pad(long n);
+
+extern const char REQUESTHEADER[], EVENTHEADER[], ERRORHEADER[], REPLYHEADER[];
+
+#define GC_function 0x00000001L
+#define GC_plane_mask 0x00000002L
+#define GC_foreground 0x00000004L
+#define GC_background 0x00000008L
+#define GC_line_width 0x00000010L
+#define GC_line_style 0x00000020L
+#define GC_cap_style 0x00000040L
+#define GC_join_style 0x00000080L
+#define GC_fill_style 0x00000100L
+#define GC_fill_rule 0x00000200L
+#define GC_tile 0x00000400L
+#define GC_stipple 0x00000800L
+#define GC_tile_stipple_x_origin 0x00001000L
+#define GC_tile_stipple_y_origin 0x00002000L
+#define GC_font 0x00004000L
+#define GC_subwindow_mode 0x00008000L
+#define GC_graphics_exposures 0x00010000L
+#define GC_clip_x_origin 0x00020000L
+#define GC_clip_y_origin 0x00040000L
+#define GC_clip_mask 0x00080000L
+#define GC_dash_offset 0x00100000L
+#define GC_dashes 0x00200000L
+#define GC_arc_mode 0x00400000L
+
+#define printreqlen(buf, fd, dvalue) \
+ do { \
+ if (IShort(&(buf)[2]) == 0 && CS[(fd)].bigreqEnabled) { \
+ printfield (buf, 4, 4, CARD32, "request length"); \
+ buf += 4; \
+ } else { \
+ printfield (buf, 2, 2, CARD16, "request length"); \
+ } \
+ } while (0)
#endif /* XSCOPE_X11_H */
diff --git a/xstats.c b/xstats.c
new file mode 100644
index 0000000..33ec4c7
--- /dev/null
+++ b/xstats.c
@@ -0,0 +1,114 @@
+#define REQUEST 0
+#define REPLY 1
+#define ERROR 2
+#define EVENT 3
+
+string_to_action (s)
+ char *s;
+{
+ if (!strcmp (s, "@@REQUEST")) return REQUEST;
+ if (!strcmp (s, "@@REPLY")) return REPLY;
+ if (!strcmp (s, "@@ERROR")) return ERROR;
+ if (!strcmp (s, "@@EVENT")) return EVENT;
+}
+
+typedef struct {
+ double time;
+ int action;
+ int client;
+ int major;
+ int minor;
+ int len;
+} ActionRec, *ActionPtr;
+
+unsigned long requestCount[256][256];
+unsigned long replyCount[256][256];
+unsigned long eventCount[256][256];
+unsigned long errorCount[256][256];
+
+unsigned long requestBytes[256][256];
+unsigned long replyBytes[256][256];
+unsigned long eventBytes[256][256];
+unsigned long errorBytes[256][256];
+
+unsigned long tRequestBytes;
+unsigned long tReplyBytes;
+unsigned long tEventBytes;
+unsigned long tErrorBytes;
+
+unsigned long tRequestCount;
+unsigned long tReplyCount;
+unsigned long tEventCount;
+unsigned long tErrorCount;
+
+dump (c, b)
+ unsigned long c[256][256];
+ unsigned long b[256][256];
+{
+ int i, j;
+ unsigned long count, bytes;
+
+ for (i = 0; i < 256; i++)
+ {
+ for (j = 0; j < 256; j++)
+ {
+ if (count = c[i][j])
+ {
+ bytes = b[i][j];
+ printf ("%3d %3d count %5d bytes %7d\n", i, j, count, bytes);
+ }
+ }
+ }
+}
+
+main ()
+{
+ ActionRec a;
+ char aname[128];
+ int i, j;
+
+ while (scanf ("%lf: %s %d %d %d %d\n",
+ &a.time, aname, &a.client, &a.major, &a.minor, &a.len) == 6)
+ {
+ a.action = string_to_action (aname);
+ switch (a.action) {
+ case REQUEST:
+ requestCount[a.major][a.minor]++;
+ requestBytes[a.major][a.minor] += a.len;
+ tRequestCount++;
+ tRequestBytes += a.len;
+ break;
+ case REPLY:
+ replyCount[a.major][a.minor]++;
+ replyBytes[a.major][a.minor] += a.len;
+ tReplyCount++;
+ tReplyBytes += a.len;
+ break;
+ case EVENT:
+ eventCount[a.major][a.minor]++;
+ eventBytes[a.major][a.minor] += a.len;
+ tEventCount++;
+ tEventBytes += a.len;
+ break;
+ case ERROR:
+ errorCount[a.major][a.minor]++;
+ errorBytes[a.major][a.minor] += a.len;
+ tErrorCount++;
+ tErrorBytes += a.len;
+ break;
+ }
+ }
+ printf ("requests:\n");
+ dump (requestCount, requestBytes);
+ printf ("replies:\n");
+ dump (replyCount, replyBytes);
+ printf ("events:\n");
+ dump (eventCount, eventBytes);
+ printf ("errors:\n");
+ dump (errorCount, errorBytes);
+ printf ("send count %5d bytes %7d\n",
+ tRequestCount, tRequestBytes);
+ printf ("recv count %5d bytes %7d\n",
+ tEventCount + tErrorCount + tReplyCount,
+ tEventBytes + tErrorBytes + tReplyBytes);
+}
Reference in a new issue View git blame Copy permalink