summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authordscho <dscho>2002-10-22 08:47:29 +0000
committerdscho <dscho>2002-10-22 08:47:29 +0000
commit347ab48bd94a04b14009f0ac98df5b42d5da11a5 (patch)
tree89eb8ab0a1e4e0052e0c737bbe0a1174135b670b
parentaf85e5fee34f7998fe3f06c799b8364a9ddbebce (diff)
downloadlibtdevnc-347ab48b.tar.gz
libtdevnc-347ab48b.zip
rdr
-rw-r--r--rdr/Exception.h71
-rw-r--r--rdr/FdInStream.cxx247
-rw-r--r--rdr/FdInStream.h72
-rw-r--r--rdr/FdOutStream.cxx113
-rw-r--r--rdr/FdOutStream.h53
-rw-r--r--rdr/FixedMemOutStream.h52
-rw-r--r--rdr/InStream.cxx35
-rw-r--r--rdr/InStream.h143
-rw-r--r--rdr/MemInStream.h47
-rw-r--r--rdr/MemOutStream.h82
-rw-r--r--rdr/NullOutStream.cxx60
-rw-r--r--rdr/NullOutStream.h42
-rw-r--r--rdr/OutStream.h152
-rw-r--r--rdr/ZlibInStream.cxx121
-rw-r--r--rdr/ZlibInStream.h59
-rw-r--r--rdr/ZlibOutStream.cxx140
-rw-r--r--rdr/ZlibOutStream.h57
-rw-r--r--rdr/types.h33
18 files changed, 1579 insertions, 0 deletions
diff --git a/rdr/Exception.h b/rdr/Exception.h
new file mode 100644
index 0000000..49c59d9
--- /dev/null
+++ b/rdr/Exception.h
@@ -0,0 +1,71 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#ifndef __RDR_EXCEPTION_H__
+#define __RDR_EXCEPTION_H__
+
+#include <stdio.h>
+#include <string.h>
+
+namespace rdr {
+
+ struct Exception {
+ enum { len = 256 };
+ char str_[len];
+ Exception(const char* s=0, const char* e="rdr::Exception") {
+ str_[0] = 0;
+ strncat(str_, e, len-1);
+ if (s) {
+ strncat(str_, ": ", len-1-strlen(str_));
+ strncat(str_, s, len-1-strlen(str_));
+ }
+ }
+ virtual const char* str() const { return str_; }
+ };
+
+ struct SystemException : public Exception {
+ int err;
+ SystemException(const char* s, int err_) : err(err_) {
+ str_[0] = 0;
+ strncat(str_, "rdr::SystemException: ", len-1);
+ strncat(str_, s, len-1-strlen(str_));
+ strncat(str_, ": ", len-1-strlen(str_));
+ strncat(str_, strerror(err), len-1-strlen(str_));
+ strncat(str_, " (", len-1-strlen(str_));
+ char buf[20];
+ sprintf(buf,"%d",err);
+ strncat(str_, buf, len-1-strlen(str_));
+ strncat(str_, ")", len-1-strlen(str_));
+ }
+ };
+
+ struct TimedOut : public Exception {
+ TimedOut(const char* s=0) : Exception(s,"rdr::TimedOut") {}
+ };
+
+ struct EndOfStream : public Exception {
+ EndOfStream(const char* s=0) : Exception(s,"rdr::EndOfStream") {}
+ };
+
+ struct FrameException : public Exception {
+ FrameException(const char* s=0) : Exception(s,"rdr::FrameException") {}
+ };
+
+}
+
+#endif
diff --git a/rdr/FdInStream.cxx b/rdr/FdInStream.cxx
new file mode 100644
index 0000000..b5c4984
--- /dev/null
+++ b/rdr/FdInStream.cxx
@@ -0,0 +1,247 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#ifdef _WIN32
+#include <winsock.h>
+#include <sys/timeb.h>
+#define read(s,b,l) recv(s,(char*)b,l,0)
+#undef errno
+#define errno WSAGetLastError()
+#else
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+// XXX should use autoconf HAVE_SYS_SELECT_H
+#ifdef _AIX
+#include <sys/select.h>
+#endif
+
+#include <rdr/FdInStream.h>
+#include <rdr/Exception.h>
+
+using namespace rdr;
+
+enum { DEFAULT_BUF_SIZE = 8192,
+ MIN_BULK_SIZE = 1024 };
+
+FdInStream::FdInStream(int fd_, int timeout_, int bufSize_)
+ : fd(fd_), timeout(timeout_), blockCallback(0), blockCallbackArg(0),
+ timing(false), timeWaitedIn100us(5), timedKbits(0),
+ bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0)
+{
+ ptr = end = start = new U8[bufSize];
+}
+
+FdInStream::FdInStream(int fd_, void (*blockCallback_)(void*),
+ void* blockCallbackArg_, int bufSize_)
+ : fd(fd_), timeout(0), blockCallback(blockCallback_),
+ blockCallbackArg(blockCallbackArg_),
+ timing(false), timeWaitedIn100us(5), timedKbits(0),
+ bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0)
+{
+ ptr = end = start = new U8[bufSize];
+}
+
+FdInStream::~FdInStream()
+{
+ delete [] start;
+}
+
+
+int FdInStream::pos()
+{
+ return offset + ptr - start;
+}
+
+void FdInStream::readBytes(void* data, int length)
+{
+ if (length < MIN_BULK_SIZE) {
+ InStream::readBytes(data, length);
+ return;
+ }
+
+ U8* dataPtr = (U8*)data;
+
+ int n = end - ptr;
+ if (n > length) n = length;
+
+ memcpy(dataPtr, ptr, n);
+ dataPtr += n;
+ length -= n;
+ ptr += n;
+
+ while (length > 0) {
+ n = readWithTimeoutOrCallback(dataPtr, length);
+ dataPtr += n;
+ length -= n;
+ offset += n;
+ }
+}
+
+
+int FdInStream::overrun(int itemSize, int nItems)
+{
+ if (itemSize > bufSize)
+ throw Exception("FdInStream overrun: max itemSize exceeded");
+
+ if (end - ptr != 0)
+ memmove(start, ptr, end - ptr);
+
+ offset += ptr - start;
+ end -= ptr - start;
+ ptr = start;
+
+ while (end < start + itemSize) {
+ int n = readWithTimeoutOrCallback((U8*)end, start + bufSize - end);
+ end += n;
+ }
+
+ if (itemSize * nItems > end - ptr)
+ nItems = (end - ptr) / itemSize;
+
+ return nItems;
+}
+
+int FdInStream::checkReadable(int fd, int timeout)
+{
+ while (true) {
+ fd_set rfds;
+ struct timeval tv;
+
+ tv.tv_sec = timeout / 1000;
+ tv.tv_usec = (timeout % 1000) * 1000;
+
+ FD_ZERO(&rfds);
+ FD_SET(fd, &rfds);
+ int n = select(fd+1, &rfds, 0, 0, &tv);
+ if (n != -1 || errno != EINTR)
+ return n;
+ fprintf(stderr,"select returned EINTR\n");
+ }
+}
+
+#ifdef _WIN32
+static void gettimeofday(struct timeval* tv, void*)
+{
+ LARGE_INTEGER counts, countsPerSec;
+ static double usecPerCount = 0.0;
+
+ if (QueryPerformanceCounter(&counts)) {
+ if (usecPerCount == 0.0) {
+ QueryPerformanceFrequency(&countsPerSec);
+ usecPerCount = 1000000.0 / countsPerSec.QuadPart;
+ }
+
+ LONGLONG usecs = (LONGLONG)(counts.QuadPart * usecPerCount);
+ tv->tv_usec = (long)(usecs % 1000000);
+ tv->tv_sec = (long)(usecs / 1000000);
+
+ } else {
+ struct timeb tb;
+ ftime(&tb);
+ tv->tv_sec = tb.time;
+ tv->tv_usec = tb.millitm * 1000;
+ }
+}
+#endif
+
+int FdInStream::readWithTimeoutOrCallback(void* buf, int len)
+{
+ struct timeval before, after;
+ if (timing)
+ gettimeofday(&before, 0);
+
+ int n = checkReadable(fd, timeout);
+
+ if (n < 0) throw SystemException("select",errno);
+
+ if (n == 0) {
+ if (timeout) throw TimedOut();
+ if (blockCallback) (*blockCallback)(blockCallbackArg);
+ }
+
+ while (true) {
+ n = ::read(fd, buf, len);
+ if (n != -1 || errno != EINTR)
+ break;
+ fprintf(stderr,"read returned EINTR\n");
+ }
+
+ if (n < 0) throw SystemException("read",errno);
+ if (n == 0) throw EndOfStream();
+
+ if (timing) {
+ gettimeofday(&after, 0);
+// fprintf(stderr,"%d.%06d\n",(after.tv_sec - before.tv_sec),
+// (after.tv_usec - before.tv_usec));
+ int newTimeWaited = ((after.tv_sec - before.tv_sec) * 10000 +
+ (after.tv_usec - before.tv_usec) / 100);
+ int newKbits = n * 8 / 1000;
+
+// if (newTimeWaited == 0) {
+// fprintf(stderr,"new kbps infinite t %d k %d\n",
+// newTimeWaited, newKbits);
+// } else {
+// fprintf(stderr,"new kbps %d t %d k %d\n",
+// newKbits * 10000 / newTimeWaited, newTimeWaited, newKbits);
+// }
+
+ // limit rate to between 10kbit/s and 40Mbit/s
+
+ if (newTimeWaited > newKbits*1000) newTimeWaited = newKbits*1000;
+ if (newTimeWaited < newKbits/4) newTimeWaited = newKbits/4;
+
+ timeWaitedIn100us += newTimeWaited;
+ timedKbits += newKbits;
+ }
+
+ return n;
+}
+
+void FdInStream::startTiming()
+{
+ timing = true;
+
+ // Carry over up to 1s worth of previous rate for smoothing.
+
+ if (timeWaitedIn100us > 10000) {
+ timedKbits = timedKbits * 10000 / timeWaitedIn100us;
+ timeWaitedIn100us = 10000;
+ }
+}
+
+void FdInStream::stopTiming()
+{
+ timing = false;
+ if (timeWaitedIn100us < timedKbits/2)
+ timeWaitedIn100us = timedKbits/2; // upper limit 20Mbit/s
+}
+
+unsigned int FdInStream::kbitsPerSecond()
+{
+ // The following calculation will overflow 32-bit arithmetic if we have
+ // received more than about 50Mbytes (400Mbits) since we started timing, so
+ // it should be OK for a single RFB update.
+
+ return timedKbits * 10000 / timeWaitedIn100us;
+}
diff --git a/rdr/FdInStream.h b/rdr/FdInStream.h
new file mode 100644
index 0000000..5a1ed43
--- /dev/null
+++ b/rdr/FdInStream.h
@@ -0,0 +1,72 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// FdInStream streams from a file descriptor.
+//
+
+#ifndef __RDR_FDINSTREAM_H__
+#define __RDR_FDINSTREAM_H__
+
+#include <rdr/InStream.h>
+
+namespace rdr {
+
+ class FdInStream : public InStream {
+
+ public:
+
+ FdInStream(int fd, int timeout=0, int bufSize=0);
+ FdInStream(int fd, void (*blockCallback)(void*), void* blockCallbackArg=0,
+ int bufSize=0);
+ virtual ~FdInStream();
+
+ int getFd() { return fd; }
+ int pos();
+ void readBytes(void* data, int length);
+ int bytesInBuf() { return end - ptr; }
+
+ void startTiming();
+ void stopTiming();
+ unsigned int kbitsPerSecond();
+ unsigned int timeWaited() { return timeWaitedIn100us; }
+
+ protected:
+ int overrun(int itemSize, int nItems);
+
+ private:
+ int checkReadable(int fd, int timeout);
+ int readWithTimeoutOrCallback(void* buf, int len);
+
+ int fd;
+ int timeout;
+ void (*blockCallback)(void*);
+ void* blockCallbackArg;
+
+ bool timing;
+ unsigned int timeWaitedIn100us;
+ unsigned int timedKbits;
+
+ int bufSize;
+ int offset;
+ U8* start;
+ };
+
+} // end of namespace rdr
+
+#endif
diff --git a/rdr/FdOutStream.cxx b/rdr/FdOutStream.cxx
new file mode 100644
index 0000000..40e7ac0
--- /dev/null
+++ b/rdr/FdOutStream.cxx
@@ -0,0 +1,113 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#ifdef _WIN32
+#include <winsock.h>
+#define write(s,b,l) send(s,(const char*)b,l,0)
+#undef errno
+#define errno WSAGetLastError()
+#else
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+#include <rdr/FdOutStream.h>
+#include <rdr/Exception.h>
+
+
+using namespace rdr;
+
+enum { DEFAULT_BUF_SIZE = 16384,
+ MIN_BULK_SIZE = 1024 };
+
+FdOutStream::FdOutStream(int fd_, int bufSize_)
+ : fd(fd_), bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0)
+{
+ ptr = start = new U8[bufSize];
+ end = start + bufSize;
+}
+
+FdOutStream::~FdOutStream()
+{
+ try {
+ flush();
+ } catch (Exception&) {
+ }
+ delete [] start;
+}
+
+
+void FdOutStream::writeBytes(const void* data, int length)
+{
+ if (length < MIN_BULK_SIZE) {
+ OutStream::writeBytes(data, length);
+ return;
+ }
+
+ const U8* dataPtr = (const U8*)data;
+
+ flush();
+
+ while (length > 0) {
+ int n = write(fd, dataPtr, length);
+
+ if (n < 0) throw SystemException("write",errno);
+
+ length -= n;
+ dataPtr += n;
+ offset += n;
+ }
+}
+
+int FdOutStream::length()
+{
+ return offset + ptr - start;
+}
+
+void FdOutStream::flush()
+{
+ U8* sentUpTo = start;
+ while (sentUpTo < ptr) {
+ int n = write(fd, (const void*) sentUpTo, ptr - sentUpTo);
+
+ if (n < 0) throw SystemException("write",errno);
+
+ sentUpTo += n;
+ offset += n;
+ }
+
+ ptr = start;
+}
+
+
+int FdOutStream::overrun(int itemSize, int nItems)
+{
+ if (itemSize > bufSize)
+ throw Exception("FdOutStream overrun: max itemSize exceeded");
+
+ flush();
+
+ if (itemSize * nItems > end - ptr)
+ nItems = (end - ptr) / itemSize;
+
+ return nItems;
+}
diff --git a/rdr/FdOutStream.h b/rdr/FdOutStream.h
new file mode 100644
index 0000000..e338852
--- /dev/null
+++ b/rdr/FdOutStream.h
@@ -0,0 +1,53 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// FdOutStream streams to a file descriptor.
+//
+
+#ifndef __RDR_FDOUTSTREAM_H__
+#define __RDR_FDOUTSTREAM_H__
+
+#include <rdr/OutStream.h>
+
+namespace rdr {
+
+ class FdOutStream : public OutStream {
+
+ public:
+
+ FdOutStream(int fd, int bufSize=0);
+ virtual ~FdOutStream();
+
+ int getFd() { return fd; }
+
+ void flush();
+ int length();
+ void writeBytes(const void* data, int length);
+
+ private:
+ int overrun(int itemSize, int nItems);
+ int fd;
+ int bufSize;
+ int offset;
+ U8* start;
+ };
+
+}
+
+#endif
diff --git a/rdr/FixedMemOutStream.h b/rdr/FixedMemOutStream.h
new file mode 100644
index 0000000..5503505
--- /dev/null
+++ b/rdr/FixedMemOutStream.h
@@ -0,0 +1,52 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// A FixedMemOutStream writes to a buffer of a fixed length.
+//
+
+#ifndef __RDR_FIXEDMEMOUTSTREAM_H__
+#define __RDR_FIXEDMEMOUTSTREAM_H__
+
+#include <rdr/OutStream.h>
+#include <rdr/Exception.h>
+
+namespace rdr {
+
+ class FixedMemOutStream : public OutStream {
+
+ public:
+
+ FixedMemOutStream(void* buf, int len) {
+ ptr = start = (U8*)buf;
+ end = start + len;
+ }
+
+ int length() { return ptr - start; }
+ void reposition(int pos) { ptr = start + pos; }
+ const void* data() { return (const void*)start; }
+
+ private:
+
+ int overrun(int itemSize, int nItems) { throw EndOfStream(); }
+ U8* start;
+ };
+
+}
+
+#endif
diff --git a/rdr/InStream.cxx b/rdr/InStream.cxx
new file mode 100644
index 0000000..b5bf509
--- /dev/null
+++ b/rdr/InStream.cxx
@@ -0,0 +1,35 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <rdr/InStream.h>
+#include <rdr/Exception.h>
+
+using namespace rdr;
+
+U32 InStream::maxStringLength = 65535;
+
+char* InStream::readString()
+{
+ U32 len = readU32();
+ if (len > maxStringLength)
+ throw Exception("InStream max string length exceeded");
+ char* str = new char[len+1];
+ readBytes(str, len);
+ str[len] = 0;
+ return str;
+}
diff --git a/rdr/InStream.h b/rdr/InStream.h
new file mode 100644
index 0000000..2e2159e
--- /dev/null
+++ b/rdr/InStream.h
@@ -0,0 +1,143 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// rdr::InStream marshalls data from a buffer stored in RDR (RFB Data
+// Representation).
+//
+
+#ifndef __RDR_INSTREAM_H__
+#define __RDR_INSTREAM_H__
+
+#include <rdr/types.h>
+#include <string.h> // for memcpy
+
+namespace rdr {
+
+ class InStream {
+
+ public:
+
+ virtual ~InStream() {}
+
+ // check() ensures there is buffer data for at least one item of size
+ // itemSize bytes. Returns the number of items in the buffer (up to a
+ // maximum of nItems).
+
+ inline int check(int itemSize, int nItems=1)
+ {
+ if (ptr + itemSize * nItems > end) {
+ if (ptr + itemSize > end)
+ return overrun(itemSize, nItems);
+
+ nItems = (end - ptr) / itemSize;
+ }
+ return nItems;
+ }
+
+ // readU/SN() methods read unsigned and signed N-bit integers.
+
+ inline U8 readU8() { check(1); return *ptr++; }
+ inline U16 readU16() { check(2); int b0 = *ptr++; int b1 = *ptr++;
+ return b0 << 8 | b1; }
+ inline U32 readU32() { check(4); int b0 = *ptr++; int b1 = *ptr++;
+ int b2 = *ptr++; int b3 = *ptr++;
+ return b0 << 24 | b1 << 16 | b2 << 8 | b3; }
+
+ inline S8 readS8() { return (S8) readU8(); }
+ inline S16 readS16() { return (S16)readU16(); }
+ inline S32 readS32() { return (S32)readU32(); }
+
+ // readString() reads a string - a U32 length followed by the data.
+ // Returns a null-terminated string - the caller should delete[] it
+ // afterwards.
+
+ char* readString();
+
+ // maxStringLength protects against allocating a huge buffer. Set it
+ // higher if you need longer strings.
+
+ static U32 maxStringLength;
+
+ inline void skip(int bytes) {
+ while (bytes > 0) {
+ int n = check(1, bytes);
+ ptr += n;
+ bytes -= n;
+ }
+ }
+
+ // readBytes() reads an exact number of bytes.
+
+ virtual void readBytes(void* data, int length) {
+ U8* dataPtr = (U8*)data;
+ U8* dataEnd = dataPtr + length;
+ while (dataPtr < dataEnd) {
+ int n = check(1, dataEnd - dataPtr);
+ memcpy(dataPtr, ptr, n);
+ ptr += n;
+ dataPtr += n;
+ }
+ }
+
+ // readOpaqueN() reads a quantity without byte-swapping.
+
+ inline U8 readOpaque8() { return readU8(); }
+ inline U16 readOpaque16() { check(2); U16 r; ((U8*)&r)[0] = *ptr++;
+ ((U8*)&r)[1] = *ptr++; return r; }
+ inline U32 readOpaque32() { check(4); U32 r; ((U8*)&r)[0] = *ptr++;
+ ((U8*)&r)[1] = *ptr++; ((U8*)&r)[2] = *ptr++;
+ ((U8*)&r)[3] = *ptr++; return r; }
+ inline U32 readOpaque24A() { check(3); U32 r=0; ((U8*)&r)[0] = *ptr++;
+ ((U8*)&r)[1] = *ptr++; ((U8*)&r)[2] = *ptr++;
+ return r; }
+ inline U32 readOpaque24B() { check(3); U32 r=0; ((U8*)&r)[1] = *ptr++;
+ ((U8*)&r)[2] = *ptr++; ((U8*)&r)[3] = *ptr++;
+ return r; }
+
+ // pos() returns the position in the stream.
+
+ virtual int pos() = 0;
+
+ // getptr(), getend() and setptr() are "dirty" methods which allow you to
+ // manipulate the buffer directly. This is useful for a stream which is a
+ // wrapper around an underlying stream.
+
+ inline const U8* getptr() const { return ptr; }
+ inline const U8* getend() const { return end; }
+ inline void setptr(const U8* p) { ptr = p; }
+
+ private:
+
+ // overrun() is implemented by a derived class to cope with buffer overrun.
+ // It ensures there are at least itemSize bytes of buffer data. Returns
+ // the number of items in the buffer (up to a maximum of nItems). itemSize
+ // is supposed to be "small" (a few bytes).
+
+ virtual int overrun(int itemSize, int nItems) = 0;
+
+ protected:
+
+ InStream() {}
+ const U8* ptr;
+ const U8* end;
+ };
+
+}
+
+#endif
diff --git a/rdr/MemInStream.h b/rdr/MemInStream.h
new file mode 100644
index 0000000..0167949
--- /dev/null
+++ b/rdr/MemInStream.h
@@ -0,0 +1,47 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#ifndef __RDR_MEMINSTREAM_H__
+#define __RDR_MEMINSTREAM_H__
+
+#include <rdr/InStream.h>
+#include <rdr/Exception.h>
+
+namespace rdr {
+
+ class MemInStream : public InStream {
+
+ public:
+
+ MemInStream(const void* data, int len) {
+ ptr = start = (const U8*)data;
+ end = start + len;
+ }
+
+ int pos() { return ptr - start; }
+ void reposition(int pos) { ptr = start + pos; }
+
+ private:
+
+ int overrun(int itemSize, int nItems) { throw EndOfStream(); }
+ const U8* start;
+ };
+
+}
+
+#endif
diff --git a/rdr/MemOutStream.h b/rdr/MemOutStream.h
new file mode 100644
index 0000000..0031388
--- /dev/null
+++ b/rdr/MemOutStream.h
@@ -0,0 +1,82 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// A MemOutStream grows as needed when data is written to it.
+//
+
+#ifndef __RDR_MEMOUTSTREAM_H__
+#define __RDR_MEMOUTSTREAM_H__
+
+#include <rdr/OutStream.h>
+
+namespace rdr {
+
+ class MemOutStream : public OutStream {
+
+ public:
+
+ MemOutStream(int len=1024) {
+ start = ptr = new U8[len];
+ end = start + len;
+ }
+
+ virtual ~MemOutStream() {
+ delete [] start;
+ }
+
+ void writeBytes(const void* data, int length) {
+ check(length);
+ memcpy(ptr, data, length);
+ ptr += length;
+ }
+
+ int length() { return ptr - start; }
+ void clear() { ptr = start; };
+ void reposition(int pos) { ptr = start + pos; }
+
+ // data() returns a pointer to the buffer.
+
+ const void* data() { return (const void*)start; }
+
+ private:
+
+ // overrun() either doubles the buffer or adds enough space for nItems of
+ // size itemSize bytes.
+
+ int overrun(int itemSize, int nItems) {
+ int len = ptr - start + itemSize * nItems;
+ if (len < (end - start) * 2)
+ len = (end - start) * 2;
+
+ U8* newStart = new U8[len];
+ memcpy(newStart, start, ptr - start);
+ ptr = newStart + (ptr - start);
+ delete [] start;
+ start = newStart;
+ end = newStart + len;
+
+ return nItems;
+ }
+
+ U8* start;
+ };
+
+}
+
+#endif
diff --git a/rdr/NullOutStream.cxx b/rdr/NullOutStream.cxx
new file mode 100644
index 0000000..aae999d
--- /dev/null
+++ b/rdr/NullOutStream.cxx
@@ -0,0 +1,60 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <rdr/NullOutStream.h>
+#include <rdr/Exception.h>
+
+using namespace rdr;
+
+static const int bufferSize = 1024;
+
+NullOutStream::NullOutStream()
+ : offset(0)
+{
+ start = ptr = new U8[bufferSize];
+ end = start + bufferSize;
+}
+
+NullOutStream::~NullOutStream()
+{
+ delete [] start;
+}
+
+int NullOutStream::length()
+{
+ return offset + ptr - start;
+}
+
+void NullOutStream::writeBytes(const void* data, int length)
+{
+ offset += length;
+}
+
+int NullOutStream::overrun(int itemSize, int nItems)
+{
+ if (itemSize > bufferSize)
+ throw Exception("NullOutStream overrun: max itemSize exceeded");
+
+ offset += ptr - start;
+ ptr = start;
+
+ if (itemSize * nItems > end - ptr)
+ nItems = (end - ptr) / itemSize;
+
+ return nItems;
+}
diff --git a/rdr/NullOutStream.h b/rdr/NullOutStream.h
new file mode 100644
index 0000000..15c588b
--- /dev/null
+++ b/rdr/NullOutStream.h
@@ -0,0 +1,42 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#ifndef __RDR_NULLOUTSTREAM_H__
+#define __RDR_NULLOUTSTREAM_H__
+
+#include <rdr/OutStream.h>
+
+namespace rdr {
+
+ class NullOutStream : public OutStream {
+
+ public:
+ NullOutStream();
+ virtual ~NullOutStream();
+ int length();
+ void writeBytes(const void* data, int length);
+
+ private:
+ int overrun(int itemSize, int nItems);
+ int offset;
+ U8* start;
+ };
+
+}
+
+#endif
diff --git a/rdr/OutStream.h b/rdr/OutStream.h
new file mode 100644
index 0000000..9aae80c
--- /dev/null
+++ b/rdr/OutStream.h
@@ -0,0 +1,152 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// rdr::OutStream marshalls data into a buffer stored in RDR (RFB Data
+// Representation).
+//
+
+#ifndef __RDR_OUTSTREAM_H__
+#define __RDR_OUTSTREAM_H__
+
+#include <rdr/types.h>
+#include <string.h> // for memcpy
+
+namespace rdr {
+
+ class OutStream {
+
+ protected:
+
+ OutStream() {}
+
+ public:
+
+ virtual ~OutStream() {}
+
+ // check() ensures there is buffer space for at least one item of size
+ // itemSize bytes. Returns the number of items which fit (up to a maximum
+ // of nItems).
+
+ inline int check(int itemSize, int nItems=1)
+ {
+ if (ptr + itemSize * nItems > end) {
+ if (ptr + itemSize > end)
+ return overrun(itemSize, nItems);
+
+ nItems = (end - ptr) / itemSize;
+ }
+ return nItems;
+ }
+
+ // writeU/SN() methods write unsigned and signed N-bit integers.
+
+ inline void writeU8( U8 u) { check(1); *ptr++ = u; }
+ inline void writeU16(U16 u) { check(2); *ptr++ = u >> 8; *ptr++ = (U8)u; }
+ inline void writeU32(U32 u) { check(4); *ptr++ = u >> 24; *ptr++ = u >> 16;
+ *ptr++ = u >> 8; *ptr++ = u; }
+
+ inline void writeS8( S8 s) { writeU8((U8)s); }
+ inline void writeS16(S16 s) { writeU16((U16)s); }
+ inline void writeS32(S32 s) { writeU32((U32)s); }
+
+ // writeString() writes a string - a U32 length followed by the data. The
+ // given string should be null-terminated (but the terminating null is not
+ // written to the stream).
+
+ inline void writeString(const char* str) {
+ U32 len = strlen(str);
+ writeU32(len);
+ writeBytes(str, len);
+ }
+
+ inline void pad(int bytes) {
+ while (bytes-- > 0) writeU8(0);
+ }
+
+ inline void skip(int bytes) {
+ while (bytes > 0) {
+ int n = check(1, bytes);
+ ptr += n;
+ bytes -= n;
+ }
+ }
+
+ // writeBytes() writes an exact number of bytes.
+
+ virtual void writeBytes(const void* data, int length) {
+ const U8* dataPtr = (const U8*)data;
+ const U8* dataEnd = dataPtr + length;
+ while (dataPtr < dataEnd) {
+ int n = check(1, dataEnd - dataPtr);
+ memcpy(ptr, dataPtr, n);
+ ptr += n;
+ dataPtr += n;
+ }
+ }
+
+ // writeOpaqueN() writes a quantity without byte-swapping.
+
+ inline void writeOpaque8( U8 u) { writeU8(u); }
+ inline void writeOpaque16(U16 u) { check(2); *ptr++ = ((U8*)&u)[0];
+ *ptr++ = ((U8*)&u)[1]; }
+ inline void writeOpaque32(U32 u) { check(4); *ptr++ = ((U8*)&u)[0];
+ *ptr++ = ((U8*)&u)[1];
+ *ptr++ = ((U8*)&u)[2];
+ *ptr++ = ((U8*)&u)[3]; }
+ inline void writeOpaque24A(U32 u) { check(3); *ptr++ = ((U8*)&u)[0];
+ *ptr++ = ((U8*)&u)[1];
+ *ptr++ = ((U8*)&u)[2]; }
+ inline void writeOpaque24B(U32 u) { check(3); *ptr++ = ((U8*)&u)[1];
+ *ptr++ = ((U8*)&u)[2];
+ *ptr++ = ((U8*)&u)[3]; }
+
+ // length() returns the length of the stream.
+
+ virtual int length() = 0;
+
+ // flush() requests that the stream be flushed.
+
+ virtual void flush() {}
+
+ // getptr(), getend() and setptr() are "dirty" methods which allow you to
+ // manipulate the buffer directly. This is useful for a stream which is a
+ // wrapper around an underlying stream.
+
+ inline U8* getptr() { return ptr; }
+ inline U8* getend() { return end; }
+ inline void setptr(U8* p) { ptr = p; }
+
+ private:
+
+ // overrun() is implemented by a derived class to cope with buffer overrun.
+ // It ensures there are at least itemSize bytes of buffer space. Returns
+ // the number of items which fit (up to a maximum of nItems). itemSize is
+ // supposed to be "small" (a few bytes).
+
+ virtual int overrun(int itemSize, int nItems) = 0;
+
+ protected:
+
+ U8* ptr;
+ U8* end;
+ };
+
+}
+
+#endif
diff --git a/rdr/ZlibInStream.cxx b/rdr/ZlibInStream.cxx
new file mode 100644
index 0000000..d4d1f1f
--- /dev/null
+++ b/rdr/ZlibInStream.cxx
@@ -0,0 +1,121 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <rdr/ZlibInStream.h>
+#include <rdr/Exception.h>
+#include <zlib.h>
+
+using namespace rdr;
+
+enum { DEFAULT_BUF_SIZE = 16384 };
+
+ZlibInStream::ZlibInStream(int bufSize_)
+ : underlying(0), bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0),
+ bytesIn(0)
+{
+ zs = new z_stream;
+ zs->zalloc = Z_NULL;
+ zs->zfree = Z_NULL;
+ zs->opaque = Z_NULL;
+ zs->next_in = Z_NULL;
+ zs->avail_in = 0;
+ if (inflateInit(zs) != Z_OK) {
+ delete zs;
+ throw Exception("ZlibInStream: inflateInit failed");
+ }
+ ptr = end = start = new U8[bufSize];
+}
+
+ZlibInStream::~ZlibInStream()
+{
+ delete [] start;
+ inflateEnd(zs);
+ delete zs;
+}
+
+void ZlibInStream::setUnderlying(InStream* is, int bytesIn_)
+{
+ underlying = is;
+ bytesIn = bytesIn_;
+ ptr = end = start;
+}
+
+int ZlibInStream::pos()
+{
+ return offset + ptr - start;
+}
+
+void ZlibInStream::reset()
+{
+ ptr = end = start;
+ if (!underlying) return;
+
+ while (bytesIn > 0) {
+ decompress();
+ end = start; // throw away any data
+ }
+ underlying = 0;
+}
+
+int ZlibInStream::overrun(int itemSize, int nItems)
+{
+ if (itemSize > bufSize)
+ throw Exception("ZlibInStream overrun: max itemSize exceeded");
+ if (!underlying)
+ throw Exception("ZlibInStream overrun: no underlying stream");
+
+ if (end - ptr != 0)
+ memmove(start, ptr, end - ptr);
+
+ offset += ptr - start;
+ end -= ptr - start;
+ ptr = start;
+
+ while (end - ptr < itemSize) {
+ decompress();
+ }
+
+ if (itemSize * nItems > end - ptr)
+ nItems = (end - ptr) / itemSize;
+
+ return nItems;
+}
+
+// decompress() calls the decompressor once. Note that this won't necessarily
+// generate any output data - it may just consume some input data.
+
+void ZlibInStream::decompress()
+{
+ zs->next_out = (U8*)end;
+ zs->avail_out = start + bufSize - end;
+
+ underlying->check(1);
+ zs->next_in = (U8*)underlying->getptr();
+ zs->avail_in = underlying->getend() - underlying->getptr();
+ if ((int)zs->avail_in > bytesIn)
+ zs->avail_in = bytesIn;
+
+ int rc = inflate(zs, Z_SYNC_FLUSH);
+ if (rc != Z_OK) {
+ throw Exception("ZlibInStream: inflate failed");
+ }
+
+ bytesIn -= zs->next_in - underlying->getptr();
+ end = zs->next_out;
+ underlying->setptr(zs->next_in);
+}
diff --git a/rdr/ZlibInStream.h b/rdr/ZlibInStream.h
new file mode 100644
index 0000000..14ad6f0
--- /dev/null
+++ b/rdr/ZlibInStream.h
@@ -0,0 +1,59 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// ZlibInStream streams from a compressed data stream ("underlying"),
+// decompressing with zlib on the fly.
+//
+
+#ifndef __RDR_ZLIBINSTREAM_H__
+#define __RDR_ZLIBINSTREAM_H__
+
+#include <rdr/InStream.h>
+
+struct z_stream_s;
+
+namespace rdr {
+
+ class ZlibInStream : public InStream {
+
+ public:
+
+ ZlibInStream(int bufSize=0);
+ virtual ~ZlibInStream();
+
+ void setUnderlying(InStream* is, int bytesIn);
+ void reset();
+ int pos();
+
+ private:
+
+ int overrun(int itemSize, int nItems);
+ void decompress();
+
+ InStream* underlying;
+ int bufSize;
+ int offset;
+ z_stream_s* zs;
+ int bytesIn;
+ U8* start;
+ };
+
+} // end of namespace rdr
+
+#endif
diff --git a/rdr/ZlibOutStream.cxx b/rdr/ZlibOutStream.cxx
new file mode 100644
index 0000000..c3a0ca2
--- /dev/null
+++ b/rdr/ZlibOutStream.cxx
@@ -0,0 +1,140 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <rdr/ZlibOutStream.h>
+#include <rdr/Exception.h>
+#include <zlib.h>
+
+using namespace rdr;
+
+enum { DEFAULT_BUF_SIZE = 16384 };
+
+ZlibOutStream::ZlibOutStream(OutStream* os, int bufSize_)
+ : underlying(os), bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0)
+{
+ zs = new z_stream;
+ zs->zalloc = Z_NULL;
+ zs->zfree = Z_NULL;
+ zs->opaque = Z_NULL;
+ if (deflateInit(zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
+ delete zs;
+ throw Exception("ZlibOutStream: deflateInit failed");
+ }
+ ptr = start = new U8[bufSize];
+ end = start + bufSize;
+}
+
+ZlibOutStream::~ZlibOutStream()
+{
+ try {
+ flush();
+ } catch (Exception&) {
+ }
+ delete [] start;
+ deflateEnd(zs);
+ delete zs;
+}
+
+void ZlibOutStream::setUnderlying(OutStream* os)
+{
+ underlying = os;
+}
+
+int ZlibOutStream::length()
+{
+ return offset + ptr - start;
+}
+
+void ZlibOutStream::flush()
+{
+ zs->next_in = start;
+ zs->avail_in = ptr - start;
+
+// fprintf(stderr,"zos flush: avail_in %d\n",zs->avail_in);
+
+ while (zs->avail_in != 0) {
+
+ do {
+ underlying->check(1);
+ zs->next_out = underlying->getptr();
+ zs->avail_out = underlying->getend() - underlying->getptr();
+
+// fprintf(stderr,"zos flush: calling deflate, avail_in %d, avail_out %d\n",
+// zs->avail_in,zs->avail_out);
+ int rc = deflate(zs, Z_SYNC_FLUSH);
+ if (rc != Z_OK) throw Exception("ZlibOutStream: deflate failed");
+
+// fprintf(stderr,"zos flush: after deflate: %d bytes\n",
+// zs->next_out-underlying->getptr());
+
+ underlying->setptr(zs->next_out);
+ } while (zs->avail_out == 0);
+ }
+
+ offset += ptr - start;
+ ptr = start;
+}
+
+int ZlibOutStream::overrun(int itemSize, int nItems)
+{
+// fprintf(stderr,"ZlibOutStream overrun\n");
+
+ if (itemSize > bufSize)
+ throw Exception("ZlibOutStream overrun: max itemSize exceeded");
+
+ while (end - ptr < itemSize) {
+ zs->next_in = start;
+ zs->avail_in = ptr - start;
+
+ do {
+ underlying->check(1);
+ zs->next_out = underlying->getptr();
+ zs->avail_out = underlying->getend() - underlying->getptr();
+
+// fprintf(stderr,"zos overrun: calling deflate, avail_in %d, avail_out %d\n",
+// zs->avail_in,zs->avail_out);
+
+ int rc = deflate(zs, 0);
+ if (rc != Z_OK) throw Exception("ZlibOutStream: deflate failed");
+
+// fprintf(stderr,"zos overrun: after deflate: %d bytes\n",
+// zs->next_out-underlying->getptr());
+
+ underlying->setptr(zs->next_out);
+ } while (zs->avail_out == 0);
+
+ // output buffer not full
+
+ if (zs->avail_in == 0) {
+ offset += ptr - start;
+ ptr = start;
+ } else {
+ // but didn't consume all the data? try shifting what's left to the
+ // start of the buffer.
+ fprintf(stderr,"z out buf not full, but in data not consumed\n");
+ memmove(start, zs->next_in, ptr - zs->next_in);
+ offset += zs->next_in - start;
+ ptr -= zs->next_in - start;
+ }
+ }
+
+ if (itemSize * nItems > end - ptr)
+ nItems = (end - ptr) / itemSize;
+
+ return nItems;
+}
diff --git a/rdr/ZlibOutStream.h b/rdr/ZlibOutStream.h
new file mode 100644
index 0000000..72f5239
--- /dev/null
+++ b/rdr/ZlibOutStream.h
@@ -0,0 +1,57 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+//
+// ZlibOutStream streams to a compressed data stream (underlying), compressing
+// with zlib on the fly.
+//
+
+#ifndef __RDR_ZLIBOUTSTREAM_H__
+#define __RDR_ZLIBOUTSTREAM_H__
+
+#include <rdr/OutStream.h>
+
+struct z_stream_s;
+
+namespace rdr {
+
+ class ZlibOutStream : public OutStream {
+
+ public:
+
+ ZlibOutStream(OutStream* os=0, int bufSize=0);
+ virtual ~ZlibOutStream();
+
+ void setUnderlying(OutStream* os);
+ void flush();
+ int length();
+
+ private:
+
+ int overrun(int itemSize, int nItems);
+
+ OutStream* underlying;
+ int bufSize;
+ int offset;
+ z_stream_s* zs;
+ U8* start;
+ };
+
+} // end of namespace rdr
+
+#endif
diff --git a/rdr/types.h b/rdr/types.h
new file mode 100644
index 0000000..00b5c40
--- /dev/null
+++ b/rdr/types.h
@@ -0,0 +1,33 @@
+//
+// Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
+//
+// This is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This software is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this software; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#ifndef __RDR_TYPES_H__
+#define __RDR_TYPES_H__
+
+namespace rdr {
+
+ typedef unsigned char U8;
+ typedef unsigned short U16;
+ typedef unsigned int U32;
+ typedef signed char S8;
+ typedef signed short S16;
+ typedef signed int S32;
+
+} // end of namespace rdr
+
+#endif