Migrating to new directory structure adopted from the RealVNC's source tree. More changes will follow.
git-svn-id: svn://svn.code.sf.net/p/tigervnc/code/trunk@590 3789f03b-4d11-0410-bbf8-ca57d06f2519
diff --git a/unix/x0vncserver/Geometry.cxx b/unix/x0vncserver/Geometry.cxx
new file mode 100644
index 0000000..ccb4e69
--- /dev/null
+++ b/unix/x0vncserver/Geometry.cxx
@@ -0,0 +1,71 @@
+/* Copyright (C) 2006 Constantin Kaplinsky. 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.
+ */
+
+//
+// Geometry.cxx
+//
+
+#include <rfb/Rect.h>
+#include <rfb/LogWriter.h>
+#include <x0vncserver/Geometry.h>
+
+static LogWriter vlog("Geometry");
+
+StringParameter Geometry::m_geometryParam("Geometry",
+ "Screen area shown to VNC clients. "
+ "Format is <width>x<height>+<offset_x>+<offset_y>, "
+ "more information in man X, section GEOMETRY SPECIFICATIONS. "
+ "If the argument is empty, full screen is shown to VNC clients.",
+ "");
+
+Geometry::Geometry(int fullWidth, int fullHeight)
+ : m_width(fullWidth), m_height(fullHeight),
+ m_offsetLeft(0), m_offsetTop(0)
+{
+ const char *param = m_geometryParam.getData();
+ if (strlen(param) != 0) {
+ int w, h;
+ int x = 0, y = 0;
+ char sign_x[2] = "+";
+ char sign_y[2] = "+";
+ int n = sscanf(param, "%dx%d%1[+-]%d%1[+-]%d",
+ &w, &h, sign_x, &x, sign_y, &y);
+ if ((n == 2 || n == 6) && w > 0 && h > 0 && x >= 0 && y >= 0) {
+ if (sign_x[0] == '-')
+ x = fullWidth - w - x;
+ if (sign_y[0] == '-')
+ y = fullHeight - h - y;
+ Rect fullRect(0, 0, fullWidth, fullHeight);
+ Rect partRect(x, y, x + w, y + h);
+ Rect r = partRect.intersect(fullRect);
+ if (r.area() > 0) {
+ m_width = r.width();
+ m_height = r.height();
+ m_offsetLeft = r.tl.x;
+ m_offsetTop = r.tl.y;
+ } else {
+ vlog.error("Requested area is out of the desktop boundaries");
+ }
+ } else {
+ vlog.error("Wrong argument format");
+ }
+ }
+ vlog.info("Desktop geometry is %dx%d+%d+%d",
+ m_width, m_height, m_offsetLeft, m_offsetTop);
+}
+
diff --git a/unix/x0vncserver/Geometry.h b/unix/x0vncserver/Geometry.h
new file mode 100644
index 0000000..95059e7
--- /dev/null
+++ b/unix/x0vncserver/Geometry.h
@@ -0,0 +1,50 @@
+/* Copyright (C) 2006 Constantin Kaplinsky. 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.
+ */
+
+//
+// Geometry.h
+//
+
+#ifndef __GEOMETRY_H__
+#define __GEOMETRY_H__
+
+#include <rfb/Configuration.h>
+
+using namespace rfb;
+
+class Geometry
+{
+public:
+ Geometry(int fullWidth, int fullHeight);
+
+ int width() const { return m_width; }
+ int height() const { return m_height; }
+ int offsetLeft() const { return m_offsetLeft; }
+ int offsetTop() const { return m_offsetTop; }
+
+protected:
+ static StringParameter m_geometryParam;
+
+ int m_width;
+ int m_height;
+ int m_offsetLeft;
+ int m_offsetTop;
+};
+
+#endif // __GEOMETRY_H__
+
diff --git a/unix/x0vncserver/Image.cxx b/unix/x0vncserver/Image.cxx
new file mode 100644
index 0000000..fc66c5a
--- /dev/null
+++ b/unix/x0vncserver/Image.cxx
@@ -0,0 +1,549 @@
+/* Copyright (C) 2002-2003 RealVNC Ltd. All Rights Reserved.
+ * Copyright (C) 2004-2005 Constantin Kaplinsky. 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.
+ */
+//
+// Image.cxx
+//
+
+#include <stdio.h>
+#include <sys/types.h>
+
+#ifdef HAVE_MITSHM
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#endif
+
+#include <rfb/LogWriter.h>
+#include <x0vncserver/Image.h>
+
+//
+// ImageCleanup is used to delete Image instances automatically on
+// program shutdown. This is important for shared memory images.
+//
+
+#include <list>
+
+class ImageCleanup {
+public:
+ std::list<Image *> images;
+
+ ~ImageCleanup()
+ {
+ while (!images.empty()) {
+ delete images.front();
+ }
+ }
+};
+
+ImageCleanup imageCleanup;
+
+//
+// Image class implementation.
+//
+
+static rfb::LogWriter vlog("Image");
+
+Image::Image(Display *d)
+ : xim(NULL), dpy(d), trueColor(true)
+{
+ imageCleanup.images.push_back(this);
+}
+
+Image::Image(Display *d, int width, int height)
+ : xim(NULL), dpy(d), trueColor(true)
+{
+ imageCleanup.images.push_back(this);
+ Init(width, height);
+}
+
+void Image::Init(int width, int height)
+{
+ Visual* vis = DefaultVisual(dpy, DefaultScreen(dpy));
+ trueColor = (vis->c_class == TrueColor);
+
+ xim = XCreateImage(dpy, vis, DefaultDepth(dpy, DefaultScreen(dpy)),
+ ZPixmap, 0, 0, width, height, BitmapPad(dpy), 0);
+
+ xim->data = (char *)malloc(xim->bytes_per_line * xim->height);
+ if (xim->data == NULL) {
+ vlog.error("malloc() failed");
+ exit(1);
+ }
+}
+
+Image::~Image()
+{
+ imageCleanup.images.remove(this);
+
+ // XDestroyImage will free xim->data if necessary
+ if (xim != NULL)
+ XDestroyImage(xim);
+}
+
+void Image::get(Window wnd, int x, int y)
+{
+ get(wnd, x, y, xim->width, xim->height);
+}
+
+void Image::get(Window wnd, int x, int y, int w, int h)
+{
+ XGetSubImage(dpy, wnd, x, y, w, h, AllPlanes, ZPixmap, xim, 0, 0);
+}
+
+//
+// Copying pixels from one image to another.
+//
+// FIXME: Use Point and Rect structures?
+// FIXME: Too many similar methods?
+//
+
+inline
+void Image::copyPixels(XImage *src,
+ int dst_x, int dst_y,
+ int src_x, int src_y,
+ int w, int h)
+{
+ const char *srcOffset =
+ src->data + (src_y * src->bytes_per_line +
+ src_x * (src->bits_per_pixel / 8));
+ char *dstOffset =
+ xim->data + (dst_y * xim->bytes_per_line +
+ dst_x * (xim->bits_per_pixel / 8));
+
+ int rowLength = w * (xim->bits_per_pixel / 8);
+
+ for (int i = 0; i < h ; i++) {
+ memcpy(dstOffset, srcOffset, rowLength);
+ srcOffset += src->bytes_per_line;
+ dstOffset += xim->bytes_per_line;
+ }
+}
+
+void Image::updateRect(XImage *src, int dst_x, int dst_y)
+{
+ // Limit width and height at destination image size.
+ int w = src->width;
+ if (dst_x + w > xim->width)
+ w = xim->width - dst_x;
+ int h = src->height;
+ if (dst_y + h > xim->height)
+ h = xim->height - dst_y;
+
+ copyPixels(src, dst_x, dst_y, 0, 0, w, h);
+}
+
+void Image::updateRect(Image *src, int dst_x, int dst_y)
+{
+ updateRect(src->xim, dst_x, dst_y);
+}
+
+void Image::updateRect(XImage *src, int dst_x, int dst_y, int w, int h)
+{
+ // Correct width and height if necessary.
+ if (w > src->width)
+ w = src->width;
+ if (dst_x + w > xim->width)
+ w = xim->width - dst_x;
+ if (h > src->height)
+ h = src->height;
+ if (dst_y + h > xim->height)
+ h = xim->height - dst_y;
+
+ copyPixels(src, dst_x, dst_y, 0, 0, w, h);
+}
+
+void Image::updateRect(Image *src, int dst_x, int dst_y, int w, int h)
+{
+ updateRect(src->xim, dst_x, dst_y, w, h);
+}
+
+void Image::updateRect(XImage *src, int dst_x, int dst_y,
+ int src_x, int src_y, int w, int h)
+{
+ // Correct width and height if necessary.
+ if (src_x + w > src->width)
+ w = src->width - src_x;
+ if (dst_x + w > xim->width)
+ w = xim->width - dst_x;
+ if (src_y + h > src->height)
+ h = src->height - src_y;
+ if (dst_y + h > xim->height)
+ h = xim->height - dst_y;
+
+ copyPixels(src, dst_x, dst_y, src_x, src_y, w, h);
+}
+
+void Image::updateRect(Image *src, int dst_x, int dst_y,
+ int src_x, int src_y, int w, int h)
+{
+ updateRect(src->xim, dst_x, dst_y, src_x, src_y, w, h);
+}
+
+#ifdef HAVE_MITSHM
+
+//
+// ShmImage class implementation.
+//
+
+static bool caughtShmError = false;
+
+static int ShmCreationXErrorHandler(Display *dpy, XErrorEvent *error)
+{
+ caughtShmError = true;
+ return 0;
+}
+
+ShmImage::ShmImage(Display *d)
+ : Image(d), shminfo(NULL)
+{
+}
+
+ShmImage::ShmImage(Display *d, int width, int height)
+ : Image(d), shminfo(NULL)
+{
+ Init(width, height);
+}
+
+// FIXME: Remove duplication of cleanup operations.
+void ShmImage::Init(int width, int height, const XVisualInfo *vinfo)
+{
+ int major, minor;
+ Bool pixmaps;
+
+ if (!XShmQueryVersion(dpy, &major, &minor, &pixmaps)) {
+ vlog.error("XShmQueryVersion() failed");
+ return;
+ }
+
+ Visual *visual;
+ int depth;
+
+ if (vinfo == NULL) {
+ visual = DefaultVisual(dpy, DefaultScreen(dpy));
+ depth = DefaultDepth(dpy, DefaultScreen(dpy));
+ } else {
+ visual = vinfo->visual;
+ depth = vinfo->depth;
+ }
+
+ trueColor = (visual->c_class == TrueColor);
+
+ shminfo = new XShmSegmentInfo;
+
+ xim = XShmCreateImage(dpy, visual, depth, ZPixmap, 0, shminfo,
+ width, height);
+ if (xim == NULL) {
+ vlog.error("XShmCreateImage() failed");
+ delete shminfo;
+ shminfo = NULL;
+ return;
+ }
+
+ shminfo->shmid = shmget(IPC_PRIVATE,
+ xim->bytes_per_line * xim->height,
+ IPC_CREAT|0777);
+ if (shminfo->shmid == -1) {
+ perror("shmget");
+ vlog.error("shmget() failed (%d bytes requested)",
+ int(xim->bytes_per_line * xim->height));
+ XDestroyImage(xim);
+ xim = NULL;
+ delete shminfo;
+ shminfo = NULL;
+ return;
+ }
+
+ shminfo->shmaddr = xim->data = (char *)shmat(shminfo->shmid, 0, 0);
+ if (shminfo->shmaddr == (char *)-1) {
+ perror("shmat");
+ vlog.error("shmat() failed (%d bytes requested)",
+ int(xim->bytes_per_line * xim->height));
+ shmctl(shminfo->shmid, IPC_RMID, 0);
+ XDestroyImage(xim);
+ xim = NULL;
+ delete shminfo;
+ shminfo = NULL;
+ return;
+ }
+
+ shminfo->readOnly = False;
+
+ XErrorHandler oldHdlr = XSetErrorHandler(ShmCreationXErrorHandler);
+ XShmAttach(dpy, shminfo);
+ XSync(dpy, False);
+ XSetErrorHandler(oldHdlr);
+ if (caughtShmError) {
+ vlog.error("XShmAttach() failed");
+ shmdt(shminfo->shmaddr);
+ shmctl(shminfo->shmid, IPC_RMID, 0);
+ XDestroyImage(xim);
+ xim = NULL;
+ delete shminfo;
+ shminfo = NULL;
+ return;
+ }
+}
+
+ShmImage::~ShmImage()
+{
+ // FIXME: Destroy image as described in MIT-SHM documentation.
+ if (shminfo != NULL) {
+ shmdt(shminfo->shmaddr);
+ shmctl(shminfo->shmid, IPC_RMID, 0);
+ delete shminfo;
+ }
+}
+
+void ShmImage::get(Window wnd, int x, int y)
+{
+ XShmGetImage(dpy, wnd, xim, x, y, AllPlanes);
+}
+
+void ShmImage::get(Window wnd, int x, int y, int w, int h)
+{
+ // FIXME: Use SHM for this as well?
+ XGetSubImage(dpy, wnd, x, y, w, h, AllPlanes, ZPixmap, xim, 0, 0);
+}
+
+#ifdef HAVE_READDISPLAY
+
+//
+// IrixOverlayShmImage class implementation.
+//
+
+IrixOverlayShmImage::IrixOverlayShmImage(Display *d)
+ : ShmImage(d), readDisplayBuf(NULL)
+{
+}
+
+IrixOverlayShmImage::IrixOverlayShmImage(Display *d, int width, int height)
+ : ShmImage(d), readDisplayBuf(NULL)
+{
+ Init(width, height);
+}
+
+void IrixOverlayShmImage::Init(int width, int height)
+{
+ // First determine the pixel format used by XReadDisplay.
+ XVisualInfo vinfo;
+ if (!getOverlayVisualInfo(&vinfo))
+ return;
+
+ // Create an SHM image of the same format.
+ ShmImage::Init(width, height, &vinfo);
+ if (xim == NULL)
+ return;
+
+ // FIXME: Check if the extension is available at run time.
+ readDisplayBuf = XShmCreateReadDisplayBuf(dpy, NULL, shminfo, width, height);
+}
+
+bool IrixOverlayShmImage::getOverlayVisualInfo(XVisualInfo *vinfo_ret)
+{
+ // First, get an image in the format returned by XReadDisplay.
+ unsigned long hints = 0, hints_ret;
+ XImage *testImage = XReadDisplay(dpy, DefaultRootWindow(dpy),
+ 0, 0, 8, 8, hints, &hints_ret);
+ if (testImage == NULL)
+ return false;
+
+ // Fill in a template for matching visuals.
+ XVisualInfo tmpl;
+ tmpl.c_class = TrueColor;
+ tmpl.depth = 24;
+ tmpl.red_mask = testImage->red_mask;
+ tmpl.green_mask = testImage->green_mask;
+ tmpl.blue_mask = testImage->blue_mask;
+
+ // List fields in template that make sense.
+ long mask = (VisualClassMask |
+ VisualRedMaskMask |
+ VisualGreenMaskMask |
+ VisualBlueMaskMask);
+
+ // We don't need that image any more.
+ XDestroyImage(testImage);
+
+ // Now, get a list of matching visuals available.
+ int nVisuals;
+ XVisualInfo *vinfo = XGetVisualInfo(dpy, mask, &tmpl, &nVisuals);
+ if (vinfo == NULL || nVisuals <= 0) {
+ if (vinfo != NULL) {
+ XFree(vinfo);
+ }
+ return false;
+ }
+
+ // Use first visual from the list.
+ *vinfo_ret = vinfo[0];
+
+ XFree(vinfo);
+
+ return true;
+}
+
+IrixOverlayShmImage::~IrixOverlayShmImage()
+{
+ if (readDisplayBuf != NULL)
+ XShmDestroyReadDisplayBuf(readDisplayBuf);
+}
+
+void IrixOverlayShmImage::get(Window wnd, int x, int y)
+{
+ get(wnd, x, y, xim->width, xim->height);
+}
+
+void IrixOverlayShmImage::get(Window wnd, int x, int y, int w, int h)
+{
+ XRectangle rect;
+ unsigned long hints = XRD_TRANSPARENT | XRD_READ_POINTER;
+
+ rect.x = x;
+ rect.y = y;
+ rect.width = w;
+ rect.height = h;
+
+ XShmReadDisplayRects(dpy, wnd,
+ &rect, 1, readDisplayBuf, -x, -y,
+ hints, &hints);
+}
+
+#endif // HAVE_READDISPLAY
+#endif // HAVE_MITSHM
+
+#ifdef HAVE_SUN_OVL
+
+//
+// SolarisOverlayImage class implementation
+//
+
+SolarisOverlayImage::SolarisOverlayImage(Display *d)
+ : Image(d)
+{
+}
+
+SolarisOverlayImage::SolarisOverlayImage(Display *d, int width, int height)
+ : Image(d)
+{
+ Init(width, height);
+}
+
+void SolarisOverlayImage::Init(int width, int height)
+{
+ // FIXME: Check if the extension is available at run time.
+ // FIXME: Maybe just read a small (e.g. 8x8) screen area then
+ // reallocate xim->data[] and correct width and height?
+ xim = XReadScreen(dpy, DefaultRootWindow(dpy), 0, 0, width, height, True);
+ if (xim == NULL) {
+ vlog.error("XReadScreen() failed");
+ return;
+ }
+}
+
+SolarisOverlayImage::~SolarisOverlayImage()
+{
+}
+
+void SolarisOverlayImage::get(Window wnd, int x, int y)
+{
+ get(wnd, x, y, xim->width, xim->height);
+}
+
+void SolarisOverlayImage::get(Window wnd, int x, int y, int w, int h)
+{
+ XImage *tmp_xim = XReadScreen(dpy, wnd, x, y, w, h, True);
+ if (tmp_xim == NULL)
+ return;
+
+ updateRect(tmp_xim, 0, 0);
+
+ XDestroyImage(tmp_xim);
+}
+
+#endif // HAVE_SUN_OVL
+
+//
+// ImageFactory class implementation
+//
+// FIXME: Make ImageFactory always create images of the same class?
+//
+
+// Prepare useful shortcuts for compile-time options.
+#if defined(HAVE_READDISPLAY) && defined(HAVE_MITSHM)
+#define HAVE_SHM_READDISPLAY
+#endif
+#if defined(HAVE_SHM_READDISPLAY) || defined(HAVE_SUN_OVL)
+#define HAVE_OVERLAY_EXT
+#endif
+
+ImageFactory::ImageFactory(bool allowShm, bool allowOverlay)
+ : mayUseShm(allowShm), mayUseOverlay(allowOverlay)
+{
+}
+
+ImageFactory::~ImageFactory()
+{
+}
+
+Image *ImageFactory::newImage(Display *d, int width, int height)
+{
+ Image *image = NULL;
+
+ // First, try to create an image with overlay support.
+
+#ifdef HAVE_OVERLAY_EXT
+ if (mayUseOverlay) {
+#if defined(HAVE_SHM_READDISPLAY)
+ if (mayUseShm) {
+ image = new IrixOverlayShmImage(d, width, height);
+ if (image->xim != NULL) {
+ return image;
+ }
+ }
+#elif defined(HAVE_SUN_OVL)
+ image = new SolarisOverlayImage(d, width, height);
+ if (image->xim != NULL) {
+ return image;
+ }
+#endif
+ if (image != NULL) {
+ delete image;
+ vlog.error("Failed to create overlay image, trying other options");
+ }
+ }
+#endif // HAVE_OVERLAY_EXT
+
+ // Now, try to use shared memory image.
+
+#ifdef HAVE_MITSHM
+ if (mayUseShm) {
+ image = new ShmImage(d, width, height);
+ if (image->xim != NULL) {
+ return image;
+ }
+
+ delete image;
+ vlog.error("Failed to create SHM image, falling back to Xlib image");
+ }
+#endif // HAVE_MITSHM
+
+ // Fall back to Xlib image.
+
+ image = new Image(d, width, height);
+ return image;
+}
diff --git a/unix/x0vncserver/Image.h b/unix/x0vncserver/Image.h
new file mode 100644
index 0000000..535cee6
--- /dev/null
+++ b/unix/x0vncserver/Image.h
@@ -0,0 +1,223 @@
+/* Copyright (C) 2002-2003 RealVNC Ltd. All Rights Reserved.
+ * Copyright (C) 2004-2005 Constantin Kaplinsky. 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.
+ */
+//
+// Image.h
+//
+
+#ifndef __IMAGE_H__
+#define __IMAGE_H__
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+//
+// Image class is an Xlib-based implementation of screen image storage.
+//
+
+class Image {
+
+public:
+
+ Image(Display *d);
+ Image(Display *d, int width, int height);
+ virtual ~Image();
+
+ bool isTrueColor() const { return trueColor; }
+
+ virtual const char *className() const {
+ return "Image";
+ }
+ virtual const char *classDesc() const {
+ return "basic Xlib image";
+ }
+
+ virtual void get(Window wnd, int x = 0, int y = 0);
+ virtual void get(Window wnd, int x, int y, int w, int h);
+
+// Copying pixels from one image to another.
+ virtual void updateRect(XImage *src, int dst_x = 0, int dst_y = 0);
+ virtual void updateRect(Image *src, int dst_x = 0, int dst_y = 0);
+ virtual void updateRect(XImage *src, int dst_x, int dst_y, int w, int h);
+ virtual void updateRect(Image *src, int dst_x, int dst_y, int w, int h);
+ virtual void updateRect(XImage *src, int dst_x, int dst_y,
+ int src_x, int src_y, int w, int h);
+ virtual void updateRect(Image *src, int dst_x, int dst_y,
+ int src_x, int src_y, int w, int h);
+
+ // Pointer to corresponding XImage, made public for efficiency.
+ // NOTE: if this field is NULL, then no methods other than Init()
+ // may be called.
+ XImage* xim;
+
+protected:
+
+ void Init(int width, int height);
+
+ // Like updateRect(), but does not check arguments.
+ void copyPixels(XImage *src,
+ int dst_x, int dst_y,
+ int src_x, int src_y,
+ int w, int h);
+
+ Display *dpy;
+ bool trueColor;
+
+};
+
+//
+// ShmImage uses MIT-SHM extension of an X server to get image data.
+//
+
+#ifdef HAVE_MITSHM
+
+#include <X11/extensions/XShm.h>
+
+class ShmImage : public Image {
+
+public:
+
+ ShmImage(Display *d);
+ ShmImage(Display *d, int width, int height);
+ virtual ~ShmImage();
+
+ virtual const char *className() const {
+ return "ShmImage";
+ }
+ virtual const char *classDesc() const {
+ return "shared memory image";
+ }
+
+ virtual void get(Window wnd, int x = 0, int y = 0);
+ virtual void get(Window wnd, int x, int y, int w, int h);
+
+protected:
+
+ void Init(int width, int height, const XVisualInfo *vinfo = NULL);
+
+ XShmSegmentInfo *shminfo;
+
+};
+
+//
+// IrixOverlayShmImage uses ReadDisplay extension of an X server to
+// get truecolor image data, regardless of the default X visual type.
+// This method is available on Irix only.
+//
+
+#ifdef HAVE_READDISPLAY
+
+#include <X11/extensions/readdisplay.h>
+
+class IrixOverlayShmImage : public ShmImage {
+
+public:
+
+ IrixOverlayShmImage(Display *d);
+ IrixOverlayShmImage(Display *d, int width, int height);
+ virtual ~IrixOverlayShmImage();
+
+ virtual const char *className() const {
+ return "IrixOverlayShmImage";
+ }
+ virtual const char *classDesc() const {
+ return "IRIX-specific SHM-aware overlay image";
+ }
+
+ virtual void get(Window wnd, int x = 0, int y = 0);
+ virtual void get(Window wnd, int x, int y, int w, int h);
+
+protected:
+
+ void Init(int width, int height);
+
+ // This method searches available X visuals for one that matches
+ // actual pixel format returned by XReadDisplay(). Returns true on
+ // success, false if there is no matching visual. On success, visual
+ // information is placed into the structure pointed by vinfo_ret.
+ bool getOverlayVisualInfo(XVisualInfo *vinfo_ret);
+
+ ShmReadDisplayBuf *readDisplayBuf;
+
+};
+
+#endif // HAVE_READDISPLAY
+#endif // HAVE_MITSHM
+
+//
+// SolarisOverlayImage uses SUN_OVL extension of an X server to get
+// truecolor image data, regardless of the default X visual type. This
+// method is available on Solaris only.
+//
+
+#ifdef HAVE_SUN_OVL
+
+#include <X11/extensions/transovl.h>
+
+class SolarisOverlayImage : public Image {
+
+public:
+
+ SolarisOverlayImage(Display *d);
+ SolarisOverlayImage(Display *d, int width, int height);
+ virtual ~SolarisOverlayImage();
+
+ virtual const char *className() const {
+ return "SolarisOverlayImage";
+ }
+ virtual const char *classDesc() const {
+ return "Solaris-specific non-SHM overlay image";
+ }
+
+ virtual void get(Window wnd, int x = 0, int y = 0);
+ virtual void get(Window wnd, int x, int y, int w, int h);
+
+protected:
+
+ void Init(int width, int height);
+
+};
+
+#endif // HAVE_SUN_OVL
+
+//
+// ImageFactory class is used to produce instances of Image-derived
+// objects that are most appropriate for current X server and user
+// settings.
+//
+
+class ImageFactory {
+
+public:
+
+ ImageFactory(bool allowShm, bool allowOverlay);
+ virtual ~ImageFactory();
+
+ bool isShmAllowed() { return mayUseShm; }
+ bool isOverlayAllowed() { return mayUseOverlay; }
+
+ virtual Image *newImage(Display *d, int width, int height);
+
+protected:
+
+ bool mayUseShm;
+ bool mayUseOverlay;
+
+};
+
+#endif // __IMAGE_H__
diff --git a/unix/x0vncserver/Makefile.in b/unix/x0vncserver/Makefile.in
new file mode 100644
index 0000000..cbb9fed
--- /dev/null
+++ b/unix/x0vncserver/Makefile.in
@@ -0,0 +1,30 @@
+
+SRCS = Image.cxx TimeMillis.cxx PollingScheduler.cxx PollingManager.cxx \
+ Geometry.cxx \
+ x0vncserver.cxx ../vncconfig_unix/QueryConnectDialog.cxx
+
+OBJS = $(SRCS:.cxx=.o)
+
+program = x0vncserver
+
+DEP_LIBS = ../rfb/librfb.a \
+ ../network/libnetwork.a \
+ ../rdr/librdr.a \
+ ../tx/libtx.a
+
+EXTRA_LIBS = @ZLIB_LIB@ @JPEG_LIB@ @INET_LIB@ @X_PRE_LIBS@ @X_LIBS@ \
+ @XTEST_LIB@ -lXext -lX11 @X_EXTRA_LIBS@
+
+# X_CFLAGS are really CPPFLAGS
+DIR_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/tx -I$(top_srcdir)/vncconfig_unix \
+ @XTEST_DEFINE@ @READDISPLAY_DEFINE@ @MITSHM_DEFINE@ @X_CFLAGS@
+
+all:: $(program)
+
+$(program): $(OBJS) buildtime.o $(DEP_LIBS)
+ rm -f $(program)
+ $(CXXLD) $(CXXFLAGS) $(LDFLAGS) -o $@ $(OBJS) buildtime.o $(DEP_LIBS) $(LIBS) $(EXTRA_LIBS)
+
+buildtime.o: $(OBJS) $(DEP_LIBS)
+
+# followed by boilerplate.mk
diff --git a/unix/x0vncserver/PollingManager.cxx b/unix/x0vncserver/PollingManager.cxx
new file mode 100644
index 0000000..a823ed4
--- /dev/null
+++ b/unix/x0vncserver/PollingManager.cxx
@@ -0,0 +1,600 @@
+/* Copyright (C) 2004-2005 Constantin Kaplinsky. 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.
+ */
+//
+// PollingManager.cxx
+//
+
+// FIXME: Don't compare pixels already marked as changed.
+// FIXME: Use Image::copyPixels() instead of Image::updateRect()?
+// In that case, note the fact that arguments are not checked.
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <X11/Xlib.h>
+#include <rfb/LogWriter.h>
+#include <rfb/VNCServer.h>
+#include <rfb/Configuration.h>
+#include <rfb/ServerCore.h>
+
+#include <x0vncserver/PollingManager.h>
+
+static LogWriter vlog("PollingMgr");
+
+BoolParameter PollingManager::pollPointer
+("PollPointer",
+ "DEBUG: Poll area under the pointer with higher priority",
+ true);
+
+IntParameter PollingManager::pollingType
+("PollingType",
+ "DEBUG: Select particular polling algorithm (0..3)",
+ 3);
+
+const int PollingManager::m_pollingOrder[32] = {
+ 0, 16, 8, 24, 4, 20, 12, 28,
+ 10, 26, 18, 2, 22, 6, 30, 14,
+ 1, 17, 9, 25, 7, 23, 15, 31,
+ 19, 3, 27, 11, 29, 13, 5, 21
+};
+
+//
+// Constructor.
+//
+// Note that dpy and image should remain valid during the object
+// lifetime, while factory is used only in the constructor itself.
+//
+
+PollingManager::PollingManager(Display *dpy, Image *image,
+ ImageFactory *factory,
+ int offsetLeft, int offsetTop)
+ : m_dpy(dpy), m_server(0), m_image(image),
+ m_offsetLeft(offsetLeft), m_offsetTop(offsetTop),
+ m_pointerPosKnown(false), m_pollingStep(0)
+{
+ // Save width and height of the screen (and the image).
+ m_width = m_image->xim->width;
+ m_height = m_image->xim->height;
+
+ // Compute width and height in 32x32 tiles.
+ m_widthTiles = (m_width + 31) / 32;
+ m_heightTiles = (m_height + 31) / 32;
+
+ // Get initial screen image.
+ m_image->get(DefaultRootWindow(m_dpy), m_offsetLeft, m_offsetTop);
+
+ // Create additional images used in polling algorithms, warn if
+ // underlying class names are different from the class name of the
+ // primary image.
+ m_rowImage = factory->newImage(m_dpy, m_width, 1);
+ m_tileImage = factory->newImage(m_dpy, 32, 32);
+ m_areaImage = factory->newImage(m_dpy, 128, 128);
+ if (strcmp(m_image->className(), m_rowImage->className()) != 0 ||
+ strcmp(m_image->className(), m_tileImage->className()) != 0 ||
+ strcmp(m_image->className(), m_areaImage->className()) != 0) {
+ vlog.error("Image types do not match (%s, %s, %s)",
+ m_rowImage->className(),
+ m_tileImage->className(),
+ m_areaImage->className());
+ }
+
+ // FIXME: Extend the comment.
+ // Create a matrix with one byte per each 32x32 tile. It will be
+ // used to limit the rate of updates on continuously-changed screen
+ // areas (like video).
+ int numTiles = m_widthTiles * m_heightTiles;
+ m_statusMatrix = new char[numTiles];
+ memset(m_statusMatrix, 0, numTiles);
+
+ // FIXME: Extend the comment.
+ // Create a matrix with one byte per each 32x32 tile. It will be
+ // used to limit the rate of updates on continuously-changed screen
+ // areas (like video).
+ m_rateMatrix = new char[numTiles];
+ m_videoFlags = new char[numTiles];
+ m_changedFlags = new char[numTiles];
+ memset(m_rateMatrix, 0, numTiles);
+ memset(m_videoFlags, 0, numTiles);
+ memset(m_changedFlags, 0, numTiles);
+}
+
+PollingManager::~PollingManager()
+{
+ delete[] m_changedFlags;
+ delete[] m_videoFlags;
+ delete[] m_rateMatrix;
+
+ delete[] m_statusMatrix;
+
+ delete m_areaImage;
+ delete m_tileImage;
+ delete m_rowImage;
+}
+
+//
+// Register VNCServer object.
+//
+
+void PollingManager::setVNCServer(VNCServer *s)
+{
+ m_server = s;
+}
+
+//
+// Update current pointer position which may be used as a hint for
+// polling algorithms.
+//
+
+void PollingManager::setPointerPos(const Point &pos)
+{
+ m_pointerPosTime = time(NULL);
+ m_pointerPos = pos;
+ m_pointerPosKnown = true;
+}
+
+//
+// Indicate that current pointer position is unknown.
+//
+
+void PollingManager::unsetPointerPos()
+{
+ m_pointerPosKnown = false;
+}
+
+//
+// DEBUG: Measuring time spent in the poll() function,
+// as well as time intervals between poll() calls.
+//
+
+#ifdef DEBUG
+void PollingManager::debugBeforePoll()
+{
+ TimeMillis timeNow;
+ int diff = timeNow.diffFrom(m_timeSaved);
+ fprintf(stderr, "[wait%4dms]\t[step %2d]\t", diff, m_pollingStep % 32);
+ m_timeSaved = timeNow;
+}
+
+void PollingManager::debugAfterPoll()
+{
+ TimeMillis timeNow;
+ int diff = timeNow.diffFrom(m_timeSaved);
+ fprintf(stderr, "[poll%4dms]\n", diff);
+ m_timeSaved = timeNow;
+}
+
+#endif
+
+//
+// Search for changed rectangles on the screen.
+//
+
+void PollingManager::poll()
+{
+#ifdef DEBUG
+ debugBeforePoll();
+#endif
+
+ // First step: full-screen polling.
+
+ bool changes1 = false;
+
+ switch((int)pollingType) {
+ case 0:
+ changes1 = poll_Dumb();
+ break;
+ case 1:
+ changes1 = poll_Traditional();
+ break;
+ case 2:
+ changes1 = poll_SkipCycles();
+ break;
+//case 3:
+ default:
+ changes1 = poll_DetectVideo();
+ break;
+ }
+
+ // Second step: optional thorough polling of the area around the pointer.
+ // We do that only if the pointer position is known and was set recently.
+
+ bool changes2 = false;
+ if (pollPointer) {
+ if (m_pointerPosKnown && time(NULL) - m_pointerPosTime >= 5) {
+ unsetPointerPos();
+ }
+ if (m_pointerPosKnown) {
+ changes2 = pollPointerArea();
+ }
+ }
+
+ // Update if needed.
+
+ if (changes1 || changes2)
+ m_server->tryUpdate();
+
+#ifdef DEBUG
+ debugAfterPoll();
+#endif
+}
+
+bool PollingManager::poll_DetectVideo()
+{
+ if (!m_server)
+ return false;
+
+ const int GRAND_STEP_DIVISOR = 8;
+ const int VIDEO_THRESHOLD_0 = 3;
+ const int VIDEO_THRESHOLD_1 = 5;
+
+ bool grandStep = (m_pollingStep % GRAND_STEP_DIVISOR == 0);
+
+ // FIXME: Save shortcuts in member variables?
+ int scanLine = m_pollingOrder[m_pollingStep++ % 32];
+ int bytesPerPixel = m_image->xim->bits_per_pixel / 8;
+ int bytesPerLine = m_image->xim->bytes_per_line;
+
+ Rect rect;
+ int nTilesChanged = 0;
+ int idx = 0;
+
+ for (int y = 0; y * 32 < m_height; y++) {
+ int tile_h = (m_height - y * 32 >= 32) ? 32 : m_height - y * 32;
+ if (scanLine >= tile_h)
+ break;
+ int scan_y = y * 32 + scanLine;
+ getRow(scan_y);
+ char *ptr_old = m_image->xim->data + scan_y * bytesPerLine;
+ char *ptr_new = m_rowImage->xim->data;
+ for (int x = 0; x * 32 < m_width; x++) {
+ int tile_w = (m_width - x * 32 >= 32) ? 32 : m_width - x * 32;
+ int nBytes = tile_w * bytesPerPixel;
+
+ char wasChanged = (memcmp(ptr_old, ptr_new, nBytes) != 0);
+ m_rateMatrix[idx] += wasChanged;
+
+ if (grandStep) {
+ if (m_rateMatrix[idx] <= VIDEO_THRESHOLD_0) {
+ m_videoFlags[idx] = 0;
+ } else if (m_rateMatrix[idx] >= VIDEO_THRESHOLD_1) {
+ m_videoFlags[idx] = 1;
+ }
+ m_rateMatrix[idx] = 0;
+ }
+
+ m_changedFlags[idx] |= wasChanged;
+ if ( m_changedFlags[idx] && (!m_videoFlags[idx] || grandStep) ) {
+ getTile32(x, y, tile_w, tile_h);
+ m_image->updateRect(m_tileImage, x * 32, y * 32);
+ rect.setXYWH(x * 32, y * 32, tile_w, tile_h);
+ m_server->add_changed(rect);
+ nTilesChanged++;
+ m_changedFlags[idx] = 0;
+ }
+
+ ptr_old += nBytes;
+ ptr_new += nBytes;
+ idx++;
+ }
+ }
+
+ if (grandStep)
+ adjustVideoArea();
+
+ return (nTilesChanged != 0);
+}
+
+bool PollingManager::poll_SkipCycles()
+{
+ if (!m_server)
+ return false;
+
+ enum {
+ NOT_CHANGED, CHANGED_ONCE, CHANGED_AGAIN
+ };
+
+ bool grandStep = (m_pollingStep % 8 == 0);
+
+ int nTilesChanged = 0;
+ int scanLine = m_pollingOrder[m_pollingStep++ % 32];
+ int bytesPerPixel = m_image->xim->bits_per_pixel / 8;
+ int bytesPerLine = m_image->xim->bytes_per_line;
+ char *pstatus = m_statusMatrix;
+ bool wasChanged;
+ Rect rect;
+
+ for (int y = 0; y * 32 < m_height; y++) {
+ int tile_h = (m_height - y * 32 >= 32) ? 32 : m_height - y * 32;
+ if (scanLine >= tile_h)
+ scanLine %= tile_h;
+ int scan_y = y * 32 + scanLine;
+ getRow(scan_y);
+ char *ptr_old = m_image->xim->data + scan_y * bytesPerLine;
+ char *ptr_new = m_rowImage->xim->data;
+ for (int x = 0; x * 32 < m_width; x++) {
+ int tile_w = (m_width - x * 32 >= 32) ? 32 : m_width - x * 32;
+ int nBytes = tile_w * bytesPerPixel;
+
+ if (grandStep || *pstatus != CHANGED_AGAIN) {
+ wasChanged = (*pstatus == CHANGED_AGAIN) ?
+ true : (memcmp(ptr_old, ptr_new, nBytes) != 0);
+ if (wasChanged) {
+ if (grandStep || *pstatus == NOT_CHANGED) {
+ getTile32(x, y, tile_w, tile_h);
+ m_image->updateRect(m_tileImage, x * 32, y * 32);
+ rect.setXYWH(x * 32, y * 32, tile_w, tile_h);
+ m_server->add_changed(rect);
+ nTilesChanged++;
+ *pstatus = CHANGED_ONCE;
+ } else {
+ *pstatus = CHANGED_AGAIN;
+ }
+ } else if (grandStep) {
+ *pstatus = NOT_CHANGED;
+ }
+ }
+
+ ptr_old += nBytes;
+ ptr_new += nBytes;
+ pstatus++;
+ }
+ }
+
+ return (nTilesChanged != 0);
+}
+
+bool PollingManager::poll_Traditional()
+{
+ if (!m_server)
+ return false;
+
+ int nTilesChanged = 0;
+ int scanLine = m_pollingOrder[m_pollingStep++ % 32];
+ int bytesPerPixel = m_image->xim->bits_per_pixel / 8;
+ int bytesPerLine = m_image->xim->bytes_per_line;
+ Rect rect;
+
+ for (int y = 0; y * 32 < m_height; y++) {
+ int tile_h = (m_height - y * 32 >= 32) ? 32 : m_height - y * 32;
+ if (scanLine >= tile_h)
+ break;
+ int scan_y = y * 32 + scanLine;
+ getRow(scan_y);
+ char *ptr_old = m_image->xim->data + scan_y * bytesPerLine;
+ char *ptr_new = m_rowImage->xim->data;
+ for (int x = 0; x * 32 < m_width; x++) {
+ int tile_w = (m_width - x * 32 >= 32) ? 32 : m_width - x * 32;
+ int nBytes = tile_w * bytesPerPixel;
+ if (memcmp(ptr_old, ptr_new, nBytes)) {
+ getTile32(x, y, tile_w, tile_h);
+ m_image->updateRect(m_tileImage, x * 32, y * 32);
+ rect.setXYWH(x * 32, y * 32, tile_w, tile_h);
+ m_server->add_changed(rect);
+ nTilesChanged++;
+ }
+ ptr_old += nBytes;
+ ptr_new += nBytes;
+ }
+ }
+
+ return (nTilesChanged != 0);
+}
+
+//
+// Simplest polling method, from the original x0vncserver of VNC4.
+//
+
+bool PollingManager::poll_Dumb()
+{
+ if (!m_server)
+ return false;
+
+ getScreen();
+ Rect rect(0, 0, m_width, m_height);
+ m_server->add_changed(rect);
+
+ // Report that some changes have been detected.
+ return true;
+}
+
+//
+// Compute coordinates of the rectangle around the pointer.
+//
+// ASSUMES: (m_pointerPosKnown != false)
+//
+
+void PollingManager::computePointerArea(Rect *r)
+{
+ int x = m_pointerPos.x - 64;
+ int y = m_pointerPos.y - 64;
+ int w = 128;
+ int h = 128;
+ if (x < 0) {
+ w += x; x = 0;
+ }
+ if (x + w > m_width) {
+ w = m_width - x;
+ }
+ if (y < 0) {
+ h += y; y = 0;
+ }
+ if (y + h > m_height) {
+ h = m_height - y;
+ }
+
+ r->setXYWH(x, y, w, h);
+}
+
+//
+// Poll the area under current pointer position. Each pixel of the
+// area should be compared. Using such polling option gives higher
+// priority to screen area under the pointer.
+//
+// ASSUMES: (m_server != NULL && m_pointerPosKnown != false)
+//
+
+bool PollingManager::pollPointerArea()
+{
+ Rect r;
+ computePointerArea(&r);
+
+ // Shortcuts for coordinates.
+ int x = r.tl.x, y = r.tl.y;
+ int w = r.width(), h = r.height();
+
+ // Get new pixels.
+ getArea128(x, y, w, h);
+
+ // Now, try to minimize the rectangle by cutting out unchanged
+ // borders (at top and bottom).
+ //
+ // FIXME: Perhaps we should work on 32x32 tiles (properly aligned)
+ // to produce a region instead of a rectangle. If there would
+ // be just one universal polling algorithm, it could be
+ // better to integrate pointer area polling into that
+ // algorithm, instead of a separate pollPointerArea()
+ // function.
+
+ // Shortcuts.
+ int bytesPerPixel = m_image->xim->bits_per_pixel / 8;
+ int oldBytesPerLine = m_image->xim->bytes_per_line;
+ int newBytesPerLine = m_areaImage->xim->bytes_per_line;
+ char *oldPtr = m_image->xim->data + y * oldBytesPerLine + x * bytesPerPixel;
+ char *newPtr = m_areaImage->xim->data;
+
+ // Check and cut out unchanged rows at the top.
+ int ty;
+ for (ty = 0; ty < h; ty++) {
+ if (memcmp(oldPtr, newPtr, w * bytesPerPixel) != 0)
+ break;
+ oldPtr += oldBytesPerLine;
+ newPtr += newBytesPerLine;
+ }
+ if (ty == h) {
+ return false; // no changes at all
+ }
+ y += ty; h -= ty;
+
+ // Check and cut out unchanged rows at the bottom.
+ oldPtr = m_image->xim->data + (y+h-1) * oldBytesPerLine + x * bytesPerPixel;
+ newPtr = m_areaImage->xim->data + (ty+h-1) * newBytesPerLine;
+ int by;
+ for (by = 0; by < h - 1; by++) {
+ if (memcmp(oldPtr, newPtr, w * bytesPerPixel) != 0)
+ break;
+ oldPtr -= oldBytesPerLine;
+ newPtr -= newBytesPerLine;
+ }
+ h -= by;
+
+ // Copy pixels.
+ m_image->updateRect(m_areaImage, x, y, 0, ty, w, h);
+
+ // Report updates to the server.
+ Rect rect(x, y, x+w, y+h);
+ m_server->add_changed(rect);
+ return true;
+}
+
+//
+// Make video area pattern more regular.
+//
+// FIXME: Replace the above with a normal comment.
+// FIXME: Is the function efficient enough?
+//
+
+void PollingManager::adjustVideoArea()
+{
+ char newFlags[m_widthTiles * m_heightTiles];
+ char *ptr = newFlags;
+ int x, y;
+
+ // DEBUG:
+ // int nVideoTiles = 0;
+
+ for (y = 0; y < m_heightTiles; y++) {
+ for (x = 0; x < m_widthTiles; x++) {
+
+ // DEBUG:
+ // nVideoTiles += m_videoFlags[y * m_widthTiles + x];
+
+ int weightedSum = 0, n;
+ if (y > 0 && x > 0) {
+ n = (m_videoFlags[ y * m_widthTiles + (x-1)] +
+ m_videoFlags[(y-1) * m_widthTiles + (x-1)] +
+ m_videoFlags[(y-1) * m_widthTiles + x ]);
+ if (n == 3) {
+ *ptr++ = 1;
+ continue;
+ }
+ weightedSum += n;
+ }
+ if (y > 0 && x < m_widthTiles - 1) {
+ n = (m_videoFlags[ y * m_widthTiles + (x+1)] +
+ m_videoFlags[(y-1) * m_widthTiles + (x+1)] +
+ m_videoFlags[(y-1) * m_widthTiles + x ]);
+ if (n == 3) {
+ *ptr++ = 1;
+ continue;
+ }
+ weightedSum += n;
+ }
+ if (y < m_heightTiles - 1 && x > 0) {
+ n = (m_videoFlags[ y * m_widthTiles + (x-1)] +
+ m_videoFlags[(y+1) * m_widthTiles + (x-1)] +
+ m_videoFlags[(y+1) * m_widthTiles + x ]);
+ if (n == 3) {
+ *ptr++ = 1;
+ continue;
+ }
+ weightedSum += n;
+ }
+ if (y < m_heightTiles - 1 && x < m_widthTiles - 1) {
+ n = (m_videoFlags[ y * m_widthTiles + (x+1)] +
+ m_videoFlags[(y+1) * m_widthTiles + (x+1)] +
+ m_videoFlags[(y+1) * m_widthTiles + x ]);
+ if (n == 3) {
+ *ptr++ = 1;
+ continue;
+ }
+ weightedSum += n;
+ }
+ *ptr++ = (weightedSum <= 3) ? 0 : m_videoFlags[y * m_widthTiles + x];
+ }
+ }
+
+ /*
+ /// DEBUG: ------------------------------------------------------
+ if (nVideoTiles) {
+ for (y = 0; y < m_heightTiles; y++) {
+ for (x = 0; x < m_widthTiles; x++) {
+ printf("%c", m_videoFlags[y * m_widthTiles + x] ? '@' : ':');
+ }
+ printf(" ");
+ for (x = 0; x < m_widthTiles; x++) {
+ printf("%c", newFlags[y * m_widthTiles + x] ? '@' : ':');
+ }
+ printf("\n");
+ }
+ printf("\n");
+ }
+ /// -------------------------------------------------------------
+ */
+
+ memcpy(m_videoFlags, newFlags, m_widthTiles * m_heightTiles);
+}
diff --git a/unix/x0vncserver/PollingManager.h b/unix/x0vncserver/PollingManager.h
new file mode 100644
index 0000000..b8eef50
--- /dev/null
+++ b/unix/x0vncserver/PollingManager.h
@@ -0,0 +1,148 @@
+/* Copyright (C) 2004-2005 Constantin Kaplinsky. 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.
+ */
+
+//
+// PollingManager.h
+//
+
+#ifndef __POLLINGMANAGER_H__
+#define __POLLINGMANAGER_H__
+
+#include <X11/Xlib.h>
+#include <rfb/VNCServer.h>
+
+#include <x0vncserver/Image.h>
+
+#ifdef DEBUG
+#include <x0vncserver/TimeMillis.h>
+#endif
+
+using namespace rfb;
+
+class PollingManager {
+
+public:
+
+ PollingManager(Display *dpy, Image *image, ImageFactory *factory,
+ int offsetLeft = 0, int offsetTop = 0);
+ virtual ~PollingManager();
+
+ void setVNCServer(VNCServer *s);
+
+ void setPointerPos(const Point &pos);
+ void unsetPointerPos();
+
+ void poll();
+
+ // Configurable parameters.
+ static BoolParameter pollPointer;
+ static IntParameter pollingType;
+
+protected:
+
+ //
+ // Implementations of different polling algorithms.
+ // Return value of true reports that some changes were detected.
+ //
+ bool poll_DetectVideo();
+ bool poll_SkipCycles();
+ bool poll_Traditional();
+ bool poll_Dumb();
+
+ // Separate polling for the area around current pointer position.
+ void computePointerArea(Rect *r);
+ bool pollPointerArea();
+
+ Display *m_dpy;
+ VNCServer *m_server;
+
+ Image *m_image;
+ int m_offsetLeft;
+ int m_offsetTop;
+ int m_width;
+ int m_height;
+ int m_widthTiles;
+ int m_heightTiles;
+
+ // Tracking pointer position for polling improvements.
+ bool m_pointerPosKnown;
+ Point m_pointerPos;
+ time_t m_pointerPosTime;
+
+private:
+
+ inline void getScreen() {
+ m_image->get(DefaultRootWindow(m_dpy), m_offsetLeft, m_offsetTop);
+ }
+
+ inline void getRow(int y) {
+ m_rowImage->get(DefaultRootWindow(m_dpy), m_offsetLeft, m_offsetTop + y);
+ }
+
+ inline void getTile32(int tx, int ty, int w, int h) {
+ if (w == 32 && h == 32) {
+ // This version of get() may be better optimized.
+ m_tileImage->get(DefaultRootWindow(m_dpy),
+ m_offsetLeft + tx * 32, m_offsetTop + ty * 32);
+ } else {
+ // Generic version of get() for arbitrary width and height.
+ m_tileImage->get(DefaultRootWindow(m_dpy),
+ m_offsetLeft + tx * 32, m_offsetTop + ty * 32, w, h);
+ }
+ }
+
+ inline void getArea128(int x, int y, int w, int h) {
+ if (w == 128 && h == 128) {
+ // This version of get() may be better optimized.
+ m_areaImage->get(DefaultRootWindow(m_dpy),
+ m_offsetLeft + x, m_offsetTop + y);
+ } else {
+ // Generic version of get() for arbitrary width and height.
+ m_areaImage->get(DefaultRootWindow(m_dpy),
+ m_offsetLeft + x, m_offsetTop + y, w, h);
+ }
+ }
+
+ void adjustVideoArea();
+
+ // Additional images used in polling algorithms.
+ Image *m_rowImage; // One row of the framebuffer
+ Image *m_tileImage; // One tile (32x32 or less)
+ Image *m_areaImage; // Area around the pointer (up to 128x128)
+
+ char *m_statusMatrix;
+
+ char *m_rateMatrix;
+ char *m_videoFlags;
+ char *m_changedFlags;
+
+ unsigned int m_pollingStep;
+ static const int m_pollingOrder[];
+
+#ifdef DEBUG
+private:
+
+ void debugBeforePoll();
+ void debugAfterPoll();
+
+ TimeMillis m_timeSaved;
+#endif
+
+};
+
+#endif // __POLLINGMANAGER_H__
diff --git a/unix/x0vncserver/PollingScheduler.cxx b/unix/x0vncserver/PollingScheduler.cxx
new file mode 100644
index 0000000..c9d8d60
--- /dev/null
+++ b/unix/x0vncserver/PollingScheduler.cxx
@@ -0,0 +1,211 @@
+/* Copyright (C) 2006 Constantin Kaplinsky. 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.
+ */
+
+//
+// PollingScheduler class implementation.
+//
+
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#include <x0vncserver/PollingScheduler.h>
+
+PollingScheduler::PollingScheduler(int interval, int maxload)
+{
+ setParameters(interval, maxload);
+ reset();
+}
+
+void PollingScheduler::setParameters(int interval, int maxload)
+{
+ m_interval = interval;
+ m_maxload = maxload;
+
+ if (m_interval < 0) {
+ m_interval = 0;
+ }
+ if (m_maxload < 1) {
+ m_maxload = 1;
+ } else if (m_maxload > 100) {
+ m_maxload = 100;
+ }
+}
+
+void PollingScheduler::reset()
+{
+ m_initialState = true;
+}
+
+void PollingScheduler::newPass()
+{
+ TimeMillis timeNow;
+
+ if (m_initialState) {
+
+ // First polling pass: initialize statistics.
+ m_initialState = false;
+ m_ratedDuration = 0;
+ m_sleeping = 0;
+ memset(m_errors, 0, sizeof(m_errors));
+ m_errorSum = 0;
+ m_errorAbsSum = 0;
+ memset(m_durations, 0, sizeof(m_durations));
+ m_durationSum = 0;
+ memset(m_slept, 0, sizeof(m_slept));
+ m_sleptSum = 0;
+ m_idx = 0;
+ m_count = 0;
+
+ } else {
+
+ // Stop sleeping if not yet.
+ if (m_sleeping)
+ sleepFinished();
+
+ // Update statistics on sleeping time and total pass duration.
+ int duration = timeNow.diffFrom(m_passStarted);
+
+ int oldest = m_durations[m_idx];
+ m_durations[m_idx] = duration;
+ m_durationSum = m_durationSum - oldest + duration;
+
+ oldest = m_slept[m_idx];
+ m_slept[m_idx] = m_sleptThisPass;
+ m_sleptSum = m_sleptSum - oldest + m_sleptThisPass;
+
+ // Compute and save the difference between actual and planned time.
+ int newError = duration - m_interval;
+ oldest = m_errors[m_idx];
+ m_errors[m_idx] = newError;
+ m_errorSum = m_errorSum - oldest + newError;
+ m_errorAbsSum = m_errorAbsSum - abs(oldest) + abs(newError);
+
+ //
+ // Below is the most important part.
+ // Compute desired duration of the upcoming polling pass.
+ //
+
+ // Estimation based on keeping up constant interval.
+ m_ratedDuration = m_interval - m_errorSum / 2;
+
+ // Estimations based on keeping up desired CPU load.
+ int optimalLoadDuration1 = 0;
+ int optimalLoadDuration8 = 0;
+ int optimalLoadDuration = 0;
+
+ if (m_count > 4) {
+ // Estimation 1 (use previous pass statistics).
+ optimalLoadDuration1 =
+ ((duration - m_sleptThisPass) * 100 + m_maxload/2) / m_maxload;
+
+ if (m_count > 16) {
+ // Estimation 2 (use history of 8 previous passes).
+ optimalLoadDuration8 =
+ ((m_durationSum - m_sleptSum) * 900 + m_maxload*4) / (m_maxload*8)
+ - m_durationSum;
+ // Mix the above two giving more priority to the first.
+ optimalLoadDuration =
+ (2 * optimalLoadDuration1 + optimalLoadDuration8) / 3;
+ } else {
+ optimalLoadDuration = optimalLoadDuration1;
+ }
+ }
+
+#ifdef DEBUG
+ fprintf(stderr, "<est %3d,%3d,%d>\t",
+ m_ratedDuration, optimalLoadDuration1, optimalLoadDuration8);
+#endif
+
+ // Choose final estimation.
+ if (m_ratedDuration < optimalLoadDuration) {
+ m_ratedDuration = optimalLoadDuration;
+ }
+ if (m_ratedDuration < 0) {
+ m_ratedDuration = 0;
+ } else if (m_ratedDuration > 500 && m_interval <= 100) {
+ m_ratedDuration = 500;
+ } else if (m_ratedDuration > 1000) {
+ m_ratedDuration = 1000;
+ }
+
+#ifdef DEBUG
+ fprintf(stderr, "<final est %3d>\t", m_ratedDuration);
+#endif
+
+ // Update ring buffer indexer (8 elements per each arrays).
+ m_idx = (m_idx + 1) & 7;
+
+ // Update pass counter.
+ m_count++;
+
+ }
+
+ m_passStarted = timeNow;
+ m_sleptThisPass = 0;
+}
+
+void PollingScheduler::sleepStarted()
+{
+ if (m_initialState || m_sleeping)
+ return;
+
+ m_sleepStarted.update();
+
+ m_sleeping = true;
+}
+
+void PollingScheduler::sleepFinished()
+{
+ if (m_initialState || !m_sleeping)
+ return;
+
+ TimeMillis timeNow;
+ m_sleptThisPass += timeNow.diffFrom(m_sleepStarted);
+
+ m_sleeping = false;
+}
+
+int PollingScheduler::millisRemaining() const
+{
+ if (m_initialState)
+ return 0;
+
+ TimeMillis timeNow;
+ int elapsed = timeNow.diffFrom(m_passStarted);
+
+ if (elapsed > m_ratedDuration)
+ return 0;
+
+ return (m_ratedDuration - elapsed);
+}
+
+bool PollingScheduler::goodTimeToPoll() const
+{
+ if (m_initialState)
+ return true;
+
+ // Average error (per 8 elements in the ring buffer).
+ int errorAvg = (m_errorAbsSum + 4) / 8;
+
+ // It's ok to poll earlier if new error is no more than half-average.
+ return (millisRemaining() <= errorAvg / 2);
+}
diff --git a/unix/x0vncserver/PollingScheduler.h b/unix/x0vncserver/PollingScheduler.h
new file mode 100644
index 0000000..2e3e5be
--- /dev/null
+++ b/unix/x0vncserver/PollingScheduler.h
@@ -0,0 +1,98 @@
+/* Copyright (C) 2006 Constantin Kaplinsky. 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.
+ */
+
+//
+// PollingScheduler class. It is used for deciding when to start new
+// polling pass, and how much time it is ok to sleep before starting.
+// PollingScheduler is given a desired polling interval, but it can
+// add time between polling passes if needed for satisfying processor
+// usage limitation.
+//
+
+#ifndef __POLLINGSCHEDULER_H__
+#define __POLLINGSCHEDULER_H__
+
+#include <x0vncserver/TimeMillis.h>
+
+class PollingScheduler {
+
+public:
+
+ PollingScheduler(int interval, int maxload = 50);
+
+ // Set polling parameters.
+ void setParameters(int interval, int maxload = 50);
+
+ // Reset the object into the initial state (no polling performed).
+ void reset();
+
+ // Tell the scheduler that new polling pass is just being started.
+ void newPass();
+
+ // Inform the scheduler about times when we sleep.
+ void sleepStarted();
+ void sleepFinished();
+
+ // This function estimates time remaining before new polling pass.
+ int millisRemaining() const;
+
+ // This function tells if it's ok to start polling pass right now.
+ bool goodTimeToPoll() const;
+
+protected:
+
+ // Parameters.
+ int m_interval;
+ int m_maxload;
+
+ // This boolean flag is true when we do not poll the screen.
+ bool m_initialState;
+
+ // Time stamp saved on starting current polling pass.
+ TimeMillis m_passStarted;
+
+ // Desired duration of current polling pass.
+ int m_ratedDuration;
+
+ // These are for measuring sleep time in current pass.
+ TimeMillis m_sleepStarted;
+ bool m_sleeping;
+ int m_sleptThisPass;
+
+ // Ring buffer for tracking past timing errors.
+ int m_errors[8];
+ int m_errorSum;
+ int m_errorAbsSum;
+
+ // Ring buffer for tracking total pass durations (work + sleep).
+ int m_durations[8];
+ int m_durationSum;
+
+ // Ring buffer for tracking past sleep times.
+ int m_slept[8];
+ int m_sleptSum;
+
+ // Indexer for all ring buffers.
+ int m_idx;
+
+ // Pass counter.
+ int m_count;
+};
+
+#endif // __POLLINGSCHEDULER_H__
+
diff --git a/unix/x0vncserver/TimeMillis.cxx b/unix/x0vncserver/TimeMillis.cxx
new file mode 100644
index 0000000..059c043
--- /dev/null
+++ b/unix/x0vncserver/TimeMillis.cxx
@@ -0,0 +1,49 @@
+/* Copyright (C) 2006 Constantin Kaplinsky. 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.
+ */
+
+//
+// TimeMillis.cxx
+//
+
+#include <x0vncserver/TimeMillis.h>
+
+// XXX Lynx/OS 2.3: get proto for gettimeofday()
+#ifdef Lynx
+#include <sys/proto.h>
+#endif
+
+TimeMillis::TimeMillis()
+{
+ update();
+}
+
+bool TimeMillis::update()
+{
+ struct timezone tz;
+ return (gettimeofday(&m_timeval, &tz) == 0);
+}
+
+int TimeMillis::diffFrom(const TimeMillis &older) const
+{
+ int diff = (int)
+ ((m_timeval.tv_usec - older.m_timeval.tv_usec + 500) / 1000 +
+ (m_timeval.tv_sec - older.m_timeval.tv_sec) * 1000);
+
+ return diff;
+}
+
diff --git a/unix/x0vncserver/TimeMillis.h b/unix/x0vncserver/TimeMillis.h
new file mode 100644
index 0000000..e79db12
--- /dev/null
+++ b/unix/x0vncserver/TimeMillis.h
@@ -0,0 +1,47 @@
+/* Copyright (C) 2006 Constantin Kaplinsky. 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.
+ */
+
+//
+// TimeMillis.h
+//
+
+#ifndef __TIMEMILLIS_H__
+#define __TIMEMILLIS_H__
+
+#include <sys/time.h>
+
+class TimeMillis {
+
+public:
+
+ TimeMillis();
+
+ // Set this object to current time, returns true on sucess.
+ bool update();
+
+ // Return difference in milliseconds between two time points.
+ int diffFrom(const TimeMillis &older) const;
+
+protected:
+
+ struct timeval m_timeval;
+
+};
+
+#endif // __TIMEMILLIS_H__
+
diff --git a/unix/x0vncserver/buildtime.c b/unix/x0vncserver/buildtime.c
new file mode 100644
index 0000000..a96031c
--- /dev/null
+++ b/unix/x0vncserver/buildtime.c
@@ -0,0 +1,18 @@
+/* Copyright (C) 2002-2003 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.
+ */
+char buildtime[] = __DATE__ " " __TIME__;
diff --git a/unix/x0vncserver/x0vncserver.cxx b/unix/x0vncserver/x0vncserver.cxx
new file mode 100644
index 0000000..80483bf
--- /dev/null
+++ b/unix/x0vncserver/x0vncserver.cxx
@@ -0,0 +1,580 @@
+/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
+ * Copyright (C) 2004-2006 Constantin Kaplinsky. 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.
+ */
+
+// FIXME: Check cases when screen width/height is not a multiply of 32.
+// e.g. 800x600.
+
+#include <strings.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <rfb/Logger_stdio.h>
+#include <rfb/LogWriter.h>
+#include <rfb/VNCServerST.h>
+#include <rfb/Configuration.h>
+#include <rfb/SSecurityFactoryStandard.h>
+#include <rfb/Timer.h>
+#include <network/TcpSocket.h>
+#include <tx/TXWindow.h>
+
+#include <vncconfig_unix/QueryConnectDialog.h>
+
+#include <signal.h>
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#ifdef HAVE_XTEST
+#include <X11/extensions/XTest.h>
+#endif
+
+#include <x0vncserver/Geometry.h>
+#include <x0vncserver/Image.h>
+#include <x0vncserver/PollingManager.h>
+#include <x0vncserver/PollingScheduler.h>
+
+// XXX Lynx/OS 2.3: protos for select(), bzero()
+#ifdef Lynx
+#include <sys/proto.h>
+#endif
+
+using namespace rfb;
+using namespace network;
+
+static LogWriter vlog("Main");
+
+IntParameter pollingCycle("PollingCycle", "Milliseconds per one polling "
+ "cycle; actual interval may be dynamically "
+ "adjusted to satisfy MaxProcessorUsage setting", 30);
+IntParameter maxProcessorUsage("MaxProcessorUsage", "Maximum percentage of "
+ "CPU time to be consumed", 35);
+BoolParameter useShm("UseSHM", "Use MIT-SHM extension if available", true);
+BoolParameter useOverlay("OverlayMode", "Use overlay mode under "
+ "IRIX or Solaris", true);
+StringParameter displayname("display", "The X display", "");
+IntParameter rfbport("rfbport", "TCP port to listen for RFB protocol",5900);
+IntParameter queryConnectTimeout("QueryConnectTimeout",
+ "Number of seconds to show the Accept Connection dialog before "
+ "rejecting the connection",
+ 10);
+StringParameter hostsFile("HostsFile", "File with IP access control rules", "");
+
+//
+// Allow the main loop terminate itself gracefully on receiving a signal.
+//
+
+static bool caughtSignal = false;
+
+static void CleanupSignalHandler(int sig)
+{
+ caughtSignal = true;
+}
+
+
+class QueryConnHandler : public VNCServerST::QueryConnectionHandler,
+ public QueryResultCallback {
+public:
+ QueryConnHandler(Display* dpy, VNCServerST* vs)
+ : display(dpy), server(vs), queryConnectDialog(0), queryConnectSock(0) {}
+ ~QueryConnHandler() { delete queryConnectDialog; }
+
+ // -=- VNCServerST::QueryConnectionHandler interface
+ virtual VNCServerST::queryResult queryConnection(network::Socket* sock,
+ const char* userName,
+ char** reason) {
+ if (queryConnectSock) {
+ *reason = strDup("Another connection is currently being queried.");
+ return VNCServerST::REJECT;
+ }
+ if (!userName) userName = "(anonymous)";
+ queryConnectSock = sock;
+ CharArray address(sock->getPeerAddress());
+ delete queryConnectDialog;
+ queryConnectDialog = new QueryConnectDialog(display, address.buf,
+ userName, queryConnectTimeout,
+ this);
+ queryConnectDialog->map();
+ return VNCServerST::PENDING;
+ }
+
+ // -=- QueryResultCallback interface
+ virtual void queryApproved() {
+ server->approveConnection(queryConnectSock, true, 0);
+ queryConnectSock = 0;
+ }
+ virtual void queryRejected() {
+ server->approveConnection(queryConnectSock, false,
+ "Connection rejected by local user");
+ queryConnectSock = 0;
+ }
+private:
+ Display* display;
+ VNCServerST* server;
+ QueryConnectDialog* queryConnectDialog;
+ network::Socket* queryConnectSock;
+};
+
+
+//
+// XPixelBuffer is a modification of FullFramePixelBuffer that does
+// not always return buffer width in getStride().
+//
+
+class XPixelBuffer : public FullFramePixelBuffer
+{
+public:
+ XPixelBuffer(const PixelFormat& pf, int width, int height,
+ rdr::U8* data_, ColourMap* cm, int stride_) :
+ FullFramePixelBuffer(pf, width, height, data_, cm), stride(stride_)
+ {
+ }
+
+ virtual int getStride() const { return stride; }
+
+protected:
+ int stride;
+};
+
+
+class XDesktop : public SDesktop, public ColourMap
+{
+public:
+ XDesktop(Display* dpy_, Geometry *geometry_)
+ : dpy(dpy_), geometry(geometry_), pb(0), server(0), image(0), pollmgr(0),
+ oldButtonMask(0), haveXtest(false), maxButtons(0), running(false)
+ {
+#ifdef HAVE_XTEST
+ int xtestEventBase;
+ int xtestErrorBase;
+ int major, minor;
+
+ if (XTestQueryExtension(dpy, &xtestEventBase,
+ &xtestErrorBase, &major, &minor)) {
+ XTestGrabControl(dpy, True);
+ vlog.info("XTest extension present - version %d.%d",major,minor);
+ haveXtest = true;
+ } else {
+#endif
+ vlog.info("XTest extension not present");
+ vlog.info("Unable to inject events or display while server is grabbed");
+#ifdef HAVE_XTEST
+ }
+#endif
+
+ }
+ virtual ~XDesktop() {
+ stop();
+ }
+
+ // -=- SDesktop interface
+
+ virtual void start(VNCServer* vs) {
+
+ // Determine actual number of buttons of the X pointer device.
+ unsigned char btnMap[8];
+ int numButtons = XGetPointerMapping(dpy, btnMap, 8);
+ maxButtons = (numButtons > 8) ? 8 : numButtons;
+ vlog.info("Enabling %d button%s of X pointer device",
+ maxButtons, (maxButtons != 1) ? "s" : "");
+
+ // Create an image for maintaining framebuffer data.
+ ImageFactory factory((bool)useShm, (bool)useOverlay);
+ image = factory.newImage(dpy, geometry->width(), geometry->height());
+ vlog.info("Allocated %s", image->classDesc());
+
+ // Create polling manager object. It will track screen changes and
+ // keep pixels of the `image' object up to date.
+ pollmgr = new PollingManager(dpy, image, &factory,
+ geometry->offsetLeft(),
+ geometry->offsetTop());
+ pollmgr->setVNCServer(vs);
+
+ pf.bpp = image->xim->bits_per_pixel;
+ pf.depth = image->xim->depth;
+ pf.bigEndian = (image->xim->byte_order == MSBFirst);
+ pf.trueColour = image->isTrueColor();
+ pf.redShift = ffs(image->xim->red_mask) - 1;
+ pf.greenShift = ffs(image->xim->green_mask) - 1;
+ pf.blueShift = ffs(image->xim->blue_mask) - 1;
+ pf.redMax = image->xim->red_mask >> pf.redShift;
+ pf.greenMax = image->xim->green_mask >> pf.greenShift;
+ pf.blueMax = image->xim->blue_mask >> pf.blueShift;
+
+ // Calculate the number of pixels in a row, with padding included.
+ int stride = image->xim->bytes_per_line * 8 / image->xim->bits_per_pixel;
+
+ // Provide pixel buffer to the server object.
+ pb = new XPixelBuffer(pf, geometry->width(), geometry->height(),
+ (rdr::U8*)image->xim->data, this, stride);
+ server = vs;
+ server->setPixelBuffer(pb);
+
+ running = true;
+ }
+
+ virtual void stop() {
+ running = false;
+
+ delete pb;
+ delete pollmgr;
+ delete image;
+
+ pb = 0;
+ pollmgr = 0;
+ image = 0;
+ }
+
+ inline bool isRunning() {
+ return running;
+ }
+
+ inline void poll() {
+ if (pollmgr)
+ pollmgr->poll();
+ }
+
+ virtual void pointerEvent(const Point& pos, int buttonMask) {
+ pollmgr->setPointerPos(pos);
+#ifdef HAVE_XTEST
+ if (!haveXtest) return;
+ XTestFakeMotionEvent(dpy, DefaultScreen(dpy),
+ geometry->offsetLeft() + pos.x,
+ geometry->offsetTop() + pos.y,
+ CurrentTime);
+ if (buttonMask != oldButtonMask) {
+ for (int i = 0; i < maxButtons; i++) {
+ if ((buttonMask ^ oldButtonMask) & (1<<i)) {
+ if (buttonMask & (1<<i)) {
+ XTestFakeButtonEvent(dpy, i+1, True, CurrentTime);
+ } else {
+ XTestFakeButtonEvent(dpy, i+1, False, CurrentTime);
+ }
+ }
+ }
+ }
+ oldButtonMask = buttonMask;
+#endif
+ }
+
+ virtual void keyEvent(rdr::U32 key, bool down) {
+#ifdef HAVE_XTEST
+ if (!haveXtest) return;
+ int keycode = XKeysymToKeycode(dpy, key);
+ if (keycode)
+ XTestFakeKeyEvent(dpy, keycode, down, CurrentTime);
+#endif
+ }
+
+ virtual void clientCutText(const char* str, int len) {
+ }
+
+ virtual Point getFbSize() {
+ return Point(pb->width(), pb->height());
+ }
+
+ // -=- ColourMap callbacks
+ virtual void lookup(int index, int* r, int* g, int* b) {
+ XColor xc;
+ xc.pixel = index;
+ if (index < DisplayCells(dpy,DefaultScreen(dpy))) {
+ XQueryColor(dpy, DefaultColormap(dpy,DefaultScreen(dpy)), &xc);
+ } else {
+ xc.red = xc.green = xc.blue = 0;
+ }
+ *r = xc.red;
+ *g = xc.green;
+ *b = xc.blue;
+ }
+
+protected:
+ Display* dpy;
+ Geometry* geometry;
+ PixelFormat pf;
+ PixelBuffer* pb;
+ VNCServer* server;
+ Image* image;
+ PollingManager* pollmgr;
+ int oldButtonMask;
+ bool haveXtest;
+ int maxButtons;
+ bool running;
+};
+
+
+class FileTcpFilter : public TcpFilter
+{
+
+public:
+
+ FileTcpFilter(const char *fname)
+ : TcpFilter("-"), fileName(NULL), lastModTime(0)
+ {
+ if (fname != NULL)
+ fileName = strdup((char *)fname);
+ }
+
+ virtual ~FileTcpFilter()
+ {
+ if (fileName != NULL)
+ free(fileName);
+ }
+
+ virtual bool verifyConnection(Socket* s)
+ {
+ if (!reloadRules()) {
+ vlog.error("Could not read IP filtering rules: rejecting all clients");
+ filter.clear();
+ filter.push_back(parsePattern("-"));
+ return false;
+ }
+
+ return TcpFilter::verifyConnection(s);
+ }
+
+protected:
+
+ bool reloadRules()
+ {
+ if (fileName == NULL)
+ return true;
+
+ struct stat st;
+ if (stat(fileName, &st) != 0)
+ return false;
+
+ if (st.st_mtime != lastModTime) {
+ // Actually reload only if the file was modified
+ FILE *fp = fopen(fileName, "r");
+ if (fp == NULL)
+ return false;
+
+ // Remove all the rules from the parent class
+ filter.clear();
+
+ // Parse the file contents adding rules to the parent class
+ char buf[32];
+ while (readLine(buf, 32, fp)) {
+ if (buf[0] && strchr("+-?", buf[0])) {
+ filter.push_back(parsePattern(buf));
+ }
+ }
+
+ fclose(fp);
+ lastModTime = st.st_mtime;
+ }
+ return true;
+ }
+
+protected:
+
+ char *fileName;
+ time_t lastModTime;
+
+private:
+
+ //
+ // NOTE: we silently truncate long lines in this function.
+ //
+
+ bool readLine(char *buf, int bufSize, FILE *fp)
+ {
+ if (fp == NULL || buf == NULL || bufSize == 0)
+ return false;
+
+ if (fgets(buf, bufSize, fp) == NULL)
+ return false;
+
+ char *ptr = strchr(buf, '\n');
+ if (ptr != NULL) {
+ *ptr = '\0'; // remove newline at the end
+ } else {
+ if (!feof(fp)) {
+ int c;
+ do { // skip the rest of a long line
+ c = getc(fp);
+ } while (c != '\n' && c != EOF);
+ }
+ }
+ return true;
+ }
+
+};
+
+char* programName;
+
+static void usage()
+{
+ fprintf(stderr, "\nusage: %s [<parameters>]\n", programName);
+ fprintf(stderr,"\n"
+ "Parameters can be turned on with -<param> or off with -<param>=0\n"
+ "Parameters which take a value can be specified as "
+ "-<param> <value>\n"
+ "Other valid forms are <param>=<value> -<param>=<value> "
+ "--<param>=<value>\n"
+ "Parameter names are case-insensitive. The parameters are:\n\n");
+ Configuration::listParams(79, 14);
+ exit(1);
+}
+
+int main(int argc, char** argv)
+{
+ initStdIOLoggers();
+ LogWriter::setLogParams("*:stderr:30");
+
+ programName = argv[0];
+ Display* dpy;
+
+ for (int i = 1; i < argc; i++) {
+ if (Configuration::setParam(argv[i]))
+ continue;
+
+ if (argv[i][0] == '-') {
+ if (i+1 < argc) {
+ if (Configuration::setParam(&argv[i][1], argv[i+1])) {
+ i++;
+ continue;
+ }
+ }
+ usage();
+ }
+
+ usage();
+ }
+
+ CharArray dpyStr(displayname.getData());
+ if (!(dpy = XOpenDisplay(dpyStr.buf[0] ? dpyStr.buf : 0))) {
+ fprintf(stderr,"%s: unable to open display \"%s\"\r\n",
+ programName, XDisplayName(displayname.getData()));
+ exit(1);
+ }
+
+ signal(SIGHUP, CleanupSignalHandler);
+ signal(SIGINT, CleanupSignalHandler);
+ signal(SIGTERM, CleanupSignalHandler);
+
+ try {
+ TXWindow::init(dpy,"x0vncserver");
+ Geometry geo(DisplayWidth(dpy, DefaultScreen(dpy)),
+ DisplayHeight(dpy, DefaultScreen(dpy)));
+ XDesktop desktop(dpy, &geo);
+ VNCServerST server("x0vncserver", &desktop);
+ QueryConnHandler qcHandler(dpy, &server);
+ server.setQueryConnectionHandler(&qcHandler);
+
+ TcpListener listener((int)rfbport);
+ vlog.info("Listening on port %d", (int)rfbport);
+
+ FileTcpFilter fileTcpFilter(hostsFile.getData());
+ if (strlen(hostsFile.getData()) != 0)
+ listener.setFilter(&fileTcpFilter);
+
+ PollingScheduler sched((int)pollingCycle, (int)maxProcessorUsage);
+
+ while (!caughtSignal) {
+ struct timeval tv;
+ fd_set rfds;
+ std::list<Socket*> sockets;
+ std::list<Socket*>::iterator i;
+
+ // Process any incoming X events
+ TXWindow::handleXEvents(dpy);
+
+ FD_ZERO(&rfds);
+ FD_SET(listener.getFd(), &rfds);
+ server.getSockets(&sockets);
+ int clients_connected = 0;
+ for (i = sockets.begin(); i != sockets.end(); i++) {
+ if ((*i)->isShutdown()) {
+ server.removeSocket(*i);
+ delete (*i);
+ } else {
+ FD_SET((*i)->getFd(), &rfds);
+ clients_connected++;
+ }
+ }
+
+ if (clients_connected) {
+ int wait_ms = sched.millisRemaining();
+ if (wait_ms > 500) {
+ wait_ms = 500;
+ }
+ tv.tv_usec = wait_ms * 1000;
+#ifdef DEBUG
+ // fprintf(stderr, "[%d]\t", wait_ms);
+#endif
+ } else {
+ sched.reset();
+ tv.tv_usec = 100000;
+ }
+ tv.tv_sec = 0;
+
+ // Do the wait...
+ sched.sleepStarted();
+ int n = select(FD_SETSIZE, &rfds, 0, 0, &tv);
+ sched.sleepFinished();
+
+ if (n < 0) {
+ if (errno == EINTR) {
+ vlog.debug("Interrupted select() system call");
+ continue;
+ } else {
+ throw rdr::SystemException("select", errno);
+ }
+ }
+
+ // Accept new VNC connections
+ if (FD_ISSET(listener.getFd(), &rfds)) {
+ Socket* sock = listener.accept();
+ if (sock) {
+ server.addSocket(sock);
+ } else {
+ vlog.status("Client connection rejected");
+ }
+ }
+
+ Timer::checkTimeouts();
+ server.checkTimeouts();
+
+ // Client list could have been changed.
+ server.getSockets(&sockets);
+
+ // Nothing more to do if there are no client connections.
+ if (sockets.empty())
+ continue;
+
+ // Process events on existing VNC connections
+ for (i = sockets.begin(); i != sockets.end(); i++) {
+ if (FD_ISSET((*i)->getFd(), &rfds))
+ server.processSocketEvent(*i);
+ }
+
+ if (desktop.isRunning() && sched.goodTimeToPoll()) {
+ sched.newPass();
+ desktop.poll();
+ }
+ }
+
+ } catch (rdr::Exception &e) {
+ vlog.error(e.str());
+ return 1;
+ }
+
+ vlog.info("Terminated");
+ return 0;
+}
diff --git a/unix/x0vncserver/x0vncserver.man b/unix/x0vncserver/x0vncserver.man
new file mode 100644
index 0000000..da9ba94
--- /dev/null
+++ b/unix/x0vncserver/x0vncserver.man
@@ -0,0 +1,33 @@
+.TH x0vncserver 1 "17 Apr 2006" "TightVNC" "Virtual Network Computing"
+.SH NAME
+x0vncserver \- VNC server which continuously polls an X display
+.SH SYNOPSIS
+.B x0vncserver
+[\fIparameters\fP]
+.SH DESCRIPTION
+.B x0vncserver
+is a VNC server which continuously polls any X display, allowing it to be
+controlled via VNC. How usable it will be depends a lot on the machine it's
+running on, and what you're expecting. It won't be as fast as Xvnc or a native
+X server with VNC support compiled in, but in many cases it is the best option
+since it is just an ordinary X application requiring no special installation.
+
+It has many of the same parameters as Xvnc. Running \fBx0vncserver -h\fP will
+give a list of parameters with descriptions. Note that you need to explicitly
+specify an appropriate password file using the PasswordFile parameter.
+
+.SH SEE ALSO
+.BR Xvnc (1)
+.BR vncpasswd (1),
+.BR vncviewer (1),
+.BR vncserver (1),
+.br
+http://www.tightvnc.com
+
+.SH AUTHOR
+Tristan Richardson, RealVNC Ltd.
+
+VNC was originally developed by the RealVNC team while at Olivetti
+Research Ltd / AT&T Laboratories Cambridge. TightVNC additions was
+implemented by Constantin Kaplinsky. Many other people participated in
+development, testing and support.