DESCRIPTION = "Conserver provides remote access to serial port \
consoles and logs all data to a central host."
HOMEPAGE = "http://www.conserver.com/"
SECTION = "console/network"
LICENSE = "BSD"

SRC_URI = "http://www.conserver.com/conserver-${PV}.tar.gz \
           file://conserver.init \
           file://conserver.default"

inherit autotools update-rc.d

# Stop install being called with -s so it doesn't try and run the host strip command
EXTRA_OEMAKE = " INSTALL_PROGRAM=install"

# Include the init script and default settings in t
--- xorg-server-X11R7.1-1.1.0/mi/miinitext.c.orig	2006-06-22 14:11:46.000000000 +0200
+++ xorg-server-X11R7.1-1.1.0/mi/miinitext.c	2006-06-22 15:26:17.000000000 +0200
@@ -385,6 +385,9 @@
 #ifdef DMXEXT
 extern void DMXExtensionInit(INITARGS);
 #endif
+#ifdef XCALIBRATE
+extern void XCalibrateExtensionInit(INITARGS);
+#endif
 #ifdef XEVIE
 extern void XevieExtensionInit(INITARGS);
 #endif
@@ -679,6 +682,9 @@
 #ifdef DAMAGE
     if (!noDamageExtension) DamageExtensionInit();
 #endif
+#ifdef  XCALIBRATE
+    XCalibrateExtensionInit ();
+#endif
 }
 
 void
--- xorg-server-X11R7.1-1.1.0/configure.ac.orig	2006-06-15 17:03:14.000000000 +0200
+++ xorg-server-X11R7.1-1.1.0/configure.ac	2006-06-24 08:21:25.000000000 +0200
@@ -407,6 +407,7 @@
 AC_ARG_ENABLE(xf86vidmode,    AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: enabled)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=yes])
 AC_ARG_ENABLE(xf86misc,       AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: enabled)]), [XF86MISC=$enableval], [XF86MISC=yes])
 AC_ARG_ENABLE(xcsecurity,     AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=yes])
+AC_ARG_ENABLE(xcalibrate,     AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no])
 AC_ARG_ENABLE(xevie,          AS_HELP_STRING([--disable-xevie], [Build XEvIE extension (default: enabled)]), [XEVIE=$enableval], [XEVIE=yes])
 AC_ARG_ENABLE(lbx,            AS_HELP_STRING([--disable-lbx], [Build LBX extension (default: no)]), [LBX=$enableval], [LBX=no])
 AC_ARG_ENABLE(appgroup,       AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: enabled)]), [APPGROUP=$enableval], [APPGROUP=yes])
@@ -641,6 +642,12 @@
 	AC_DEFINE(XCSECURITY, 1, [Build Security extension])
 fi
 
+AM_CONDITIONAL(XCALIBRATE, [test "x$XCALIBRATE" = xyes])
+if test "x$XCALIBRATE" = xyes; then
+	AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension])
+	REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto"
+fi
+
 AM_CONDITIONAL(XEVIE, [test "x$XEVIE" = xyes])
 if test "x$XEVIE" = xyes; then
 	AC_DEFINE(XEVIE, 1, [Build XEvIE extension])
@@ -1466,7 +1473,7 @@
     KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
     KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
     KDRIVE_STUB_LIB='$(top_builddir)/hw/kdrive/src/libkdrivestubs.a'
-    KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB"
+    KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_PURE_LIBS $KDRIVE_OS_LIB $KDRIVE_STUB_LIB"
 
     # check if we can build Xephyr
     PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
--- xorg-server-X11R7.1-1.1.0/include/kdrive-config.h.in.orig	2006-06-22 14:22:07.000000000 +0200
+++ xorg-server-X11R7.1-1.1.0/include/kdrive-config.h.in	2006-06-22 14:33:29.000000000 +0200
@@ -22,4 +22,7 @@
 /* Support tslib touchscreen abstraction library */
 #undef TSLIB
 
+/* Enable XCalibrate extension */
+#undef XCALIBRATE
+
 #endif /* _KDRIVE_CONFIG_H_ */
--- xorg-server-X11R7.1-1.1.0/Xext/Makefile.am.orig	2006-06-15 17:06:43.000000000 +0200
+++ xorg-server-X11R7.1-1.1.0/Xext/Makefile.am	2006-06-15 18:12:40.000000000 +0200
@@ -78,6 +78,11 @@
 AM_CFLAGS += -DDEFAULTPOLICYFILE=\"$(SERVERCONFIGdir)/SecurityPolicy\"
 endif
 
+XCALIBRATE_SRCS = xcalibrate.c
+if XCALIBRATE
+BUILTIN_SRCS += $(XCALIBRATE_SRCS)
+endif
+
 # X EVent Interception Extension: allows accessibility helpers & composite
 # managers to intercept events from input devices and transform as needed
 # before the clients see them.
@@ -155,6 +160,7 @@
 	$(SCREENSAVER_SRCS) \
 	$(XCSECURITY_SRCS) \
 	$(XINERAMA_SRCS) \
+	$(XCALIBRATE_SRCS) \
 	$(XEVIE_SRCS) \
 	$(XPRINT_SRCS) \
 	$(APPGROUP_SRCS) \
--- xorg-server-X11R7.1-1.1.0/Xext/xcalibrate.c.orig	2006-06-15 17:05:19.000000000 +0200
+++ xorg-server-X11R7.1-1.1.0/Xext/xcalibrate.c	2006-06-22 15:15:09.000000000 +0200
@@ -0,0 +1,262 @@
+/*
+ * $Id: xcalibrate.c,v 3.1 2004/06/02 20:49:50 pb Exp $
+ *
+ * Copyright © 2003 Philip Blundell
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Philip Blundell not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Philip Blundell makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * PHILIP BLUNDELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL PHILIP BLUNDELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_KDRIVE_CONFIG_H
+#include <kdrive-config.h>
+#endif
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "swaprep.h"
+
+#include <X11/extensions/xcalibrateproto.h>
+#include <X11/extensions/xcalibratewire.h>
+
+extern void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure);
+extern void *tslib_raw_event_closure;
+
+static CARD8	XCalibrateReqCode;
+int		XCalibrateEventBase;
+int		XCalibrateReqBase;
+int		XCalibrateErrorBase;
+
+static ClientPtr xcalibrate_client;
+
+static void
+xcalibrate_event_hook (int x, int y, int pressure, void *closure)
+{
+  ClientPtr pClient = (ClientPtr) closure;
+  xXCalibrateRawTouchscreenEvent	ev;
+
+  ev.type = XCalibrateEventBase + X_XCalibrateRawTouchscreen;
+  ev.sequenceNumber = pClient->sequence;
+  ev.x = x;
+  ev.y = y;
+  ev.pressure = pressure;
+
+  if (!pClient->clientGone)
+    WriteEventsToClient (pClient, 1, (xEvent *) &ev);
+}
+
+static int
+ProcXCalibrateQueryVersion (ClientPtr client)
+{
+  REQUEST(xXCalibrateQueryVersionReq);
+  xXCalibrateQueryVersionReply rep;
+  CARD16 client_major, client_minor;  /* not used */
+
+  REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq);
+
+  client_major = stuff->majorVersion;
+  client_minor = stuff->minorVersion;
+
+  fprintf(stderr, "%s(): called\n", __func__); 
+
+  rep.type = X_Reply;
+  rep.length = 0;
+  rep.sequenceNumber = client->sequence;
+  rep.majorVersion = XCALIBRATE_MAJOR_VERSION;
+  rep.minorVersion = XCALIBRATE_MINOR_VERSION;   
+  if (client->swapped) { 
+    int n;
+    swaps(&rep.sequenceNumber, n);
+    swapl(&rep.length, n);     
+    swaps(&rep.majorVersion, n);
+    swaps(&rep.minorVersion, n);
+  }
+  WriteToClient(client, sizeof (xXCalibrateQueryVersionReply), (char *)&rep);
+  return (client->noClientException);
+}
+
+static int
+SProcXCalibrateQueryVersion (ClientPtr client)
+{
+    REQUEST(xXCalibrateQueryVersionReq);
+    int n;
+
+    REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq);
+    swaps(&stuff->majorVersion,n);
+    swaps(&stuff->minorVersion,n);
+    return ProcXCalibrateQueryVersion(client);
+}
+
+static int
+ProcXCalibrateSetRawMode (ClientPtr client)
+{
+  REQUEST(xXCalibrateRawModeReq);
+  xXCalibrateRawModeReply rep;
+
+  REQUEST_SIZE_MATCH (xXCalibrateRawModeReq);
+
+  memset (&rep, 0, sizeof (rep));
+  rep.type = X_Reply;
+  rep.sequenceNumber = client->sequence;
+
+  if (stuff->on)
+    {
+      if (xcalibrate_client == NULL)
+	{
+	  /* Start calibrating.  */
+	  xcalibrate_client = client;
+	  tslib_raw_event_hook = xcalibrate_event_hook;
+	  tslib_raw_event_closure = client;
+	  rep.status = GrabSuccess;
+	}
+      else
+	{
+	  rep.status = AlreadyGrabbed;
+	}
+    }
+  else
+    {
+      if (xcalibrate_client == client)
+	{
+	  /* Stop calibrating.  */
+	  xcalibrate_client = NULL;
+	  tslib_raw_event_hook = NULL;
+	  tslib_raw_event_closure = NULL;
+	  rep.status = GrabSuccess;
+
+	  /* Cycle input off and on to reload configuration.  */
+	  KdDisableInput ();
+	  KdEnableInput ();
+	}
+      else
+	{
+	  rep.status = AlreadyGrabbed;
+	}
+    }
+
+  if (client->swapped)
+    {
+      int n;
+
+      swaps (&rep.sequenceNumber, n);
+      swaps (&rep.status, n);
+    }
+  WriteToClient(client, sizeof (rep), (char *) &rep);
+  return (client->noClientException);
+}
+
+
+static int
+SProcXCalibrateSetRawMode (ClientPtr client)
+{
+  REQUEST(xXCalibrateRawModeReq);
+  int n;
+
+  REQUEST_SIZE_MATCH (xXCalibrateRawModeReq);
+
+  swaps(&stuff->on, n);
+
+  return ProcXCalibrateSetRawMode(client);
+}
+
+static void
+XCalibrateResetProc (ExtensionEntry *extEntry) 
+{ 
+}
+
+static int
+ProcXCalibrateDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    switch (stuff->data) {
+    case X_XCalibrateQueryVersion:
+        return ProcXCalibrateQueryVersion(client);
+    case X_XCalibrateRawMode:
+        return ProcXCalibrateSetRawMode(client);
+    default: break;
+    }
+
+    return BadRequest;
+}
+
+static int
+SProcXCalibrateDispatch (ClientPtr client)
+{
+    REQUEST(xReq);
+    int n;
+
+    swaps(&stuff->length,n);
+
+    switch (stuff->data) {
+    case X_XCalibrateQueryVersion:
+        return SProcXCalibrateQueryVersion(client);
+    case X_XCalibrateRawMode:
+        return SProcXCalibrateSetRawMode(client);
+
+    default: break;
+    }
+
+    return BadRequest;
+}
+
+static void
+XCalibrateClientCallback (CallbackListPtr	*list,
+			  pointer		closure,
+			  pointer		data)
+{
+    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
+    ClientPtr		pClient = clientinfo->client;
+
+    if (clientinfo->setup == NULL
+	&& xcalibrate_client != NULL
+	&& xcalibrate_client == pClient)
+      {
+	/* Stop calibrating.  */
+	xcalibrate_client = NULL;
+	tslib_raw_event_hook = NULL;
+	tslib_raw_event_closure = NULL;
+      }
+}
+
+void
+XCalibrateExtensionInit(void)
+{
+  ExtensionEntry *extEntry;
+
+  if (!AddCallback (&ClientStateCallback, XCalibrateClientCallback, 0))
+    return;  
+
+  extEntry = AddExtension(XCALIBRATE_NAME, XCalibrateNumberEvents, XCalibrateNumberErrors,
+			  ProcXCalibrateDispatch, SProcXCalibrateDispatch,
+			  XCalibrateResetProc, StandardMinorOpcode);
+
+  if (!extEntry)
+    return;
+
+  XCalibrateReqCode = (unsigned char)extEntry->base;
+  XCalibrateEventBase = extEntry->eventBase;
+  XCalibrateErrorBase = extEntry->errorBase;
+
+  xcalibrate_client = 0;
+}