Merge lp:~lazyranma/ubuntu/wily/g15daemon/g15daemon.dev into lp:ubuntu/wily/g15daemon

[Alexander Ponyatykh]

I've made several changes to g15daemon package, including fixing several bugs and adding native upstart job and systemd unit files. Changes are made in several commits, so you can inspect each change individually. Please review changes and merge them into the main branch if possible.

Full changelog:
  * Converted source to 3.0 (quilt) format.
  * debian/g15daemon.init: Replaced /dev/input/uinput with /dev/uinput
    (related to LP #617101).
  * debian/docs: removed obsolete file.
  * Do not fail package installation/removal if g15daemon fails to start/stop
    (LP: #617101, LP: #1103275).
  * debian/g15daemon.init: added dependency on $remote_fs
  * debian/g15daemon.init: now sources /lib/lsb/init-functions
  * Added debian/patches/07-reinit-on-any-error.diff: reinitialize on any
    error returned by libusb to correctly recover after suspend/resume.
    (LP: #1357556)
  * debian/control: removed dependency on libg15daemon-client1 for g15daemon
  * debian/control: changed priority of g15daemon to optional
  * Added native upstart job and systemd service. (LP: #1441365)
  * debian/g15daemon.default: removed SWITCH_KEY option to keep systemd and
    upstart scripts simple.

[Sebastien Bacher (seb128)]

Thanks, that's quite some changes. Do you think some could be forwarded to Debian?

[Daniel Holbach (dholbach)]

Yeah, it'd be better to have the Debian maintainer's buy-in as well.

Unmerged revisions

33. By Alexander Ponyatykh on 2019-04-29

Cleanup.

32. By Alexander Ponyatykh on 2019-04-29

Migrated from cdbs to debhelper.

31. By Alexander Ponyatykh on 2019-04-28

Merged with Ubuntu main branch.
Removed upstart service file.

30. By Alexander Ponyatykh on 2015-05-21

debian/g15daemon.service: Added documantation link.

29. By Alexander Ponyatykh on 2015-05-21

Added man link to g15daemon.service

28. By Alexander Ponyatykh on 2015-05-21

changed version

27. By Alexander Ponyatykh on 2015-05-21

Updated changelog

26. By Alexander Ponyatykh on 2015-05-21

Added native upstart job and systemd service. (LP: #1441365)
debian/g15daemon.default: removed SWITCH_KEY option to keep systemd and
upstart scripts simple.

25. By Alexander Ponyatykh on 2015-05-21

debian/control: removed dependency on libg15daemon-client1 for g15daemon
debian/control: changed priority of g15daemon to optional (Policy 2.5)

24. By Alexander Ponyatykh on 2015-05-20

Fixed CDBS warning

=== added directory '.pc'
=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2015-05-21 10:27:39 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2015-05-21 10:27:39 +0000
@@ -0,0 +1,1 @@
+series

=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2015-05-21 10:27:39 +0000
@@ -0,0 +1,1 @@
+2

=== added directory '.pc/01-remove-x11-setup-from-man.diff'
=== added directory '.pc/01-remove-x11-setup-from-man.diff/Documentation'
=== added file '.pc/01-remove-x11-setup-from-man.diff/Documentation/g15daemon.1'
--- .pc/01-remove-x11-setup-from-man.diff/Documentation/g15daemon.1	1970-01-01 00:00:00 +0000
+++ .pc/01-remove-x11-setup-from-man.diff/Documentation/g15daemon.1	2015-05-21 10:27:39 +0000
@@ -0,0 +1,163 @@
+.TH "G15Daemon" "1" "1.3" "G15tools - G15Daemon" "1"
+.SH "NAME"
+g15daemon \- provides access to extra keys and the LCD available on the logitech G15 keyboard.
+.SH "DESCRIPTION"
+G15Daemon allows users access to all extra keys by decoding them and pushing them back into the kernel via the linux UINPUT driver.  This driver must be loaded before g15daemon can be used for keyboard access.
+
+The G15 LCD is also supported.  By default, with no other clients active, g15daemon will display a clock.  Client applications and scripts can access the LCD via a simple API.
+.SH "OPTIONS"
+The current version of G15Daemon understands the following options:
+.br 
+.P 
+.HP
+\-v 	  Show version info.
+.P
+.HP
+\-s	 By default, g15daemon uses the L1 key to switch between client screens.  Using this switch on the cmdline alters this, making
+MR (Macro Record) the button to achieve this function.
+.P
+.HP
+\-k	  Stop a previously running copy of G15Daemon.  For the keys and LCD to work, you'll have to restart the daemon manually.
+.P
+.HP
+\-h	  Show a brief summary of commandline options available.
+
+.SH "BASIC USAGE"
+G15Daemon must be run as the root user, either from a startup script (sample scripts are available in the contrib folder) or manually, via the su command.  
+
+To run the daemon with default options, run:
+
+	g15daemon
+
+or
+
+	g15daemon \-s
+to have the MR key as the client screen switch.
+
+If all required libraries are installed and in locations known to your operating system, the daemon will slip quietly into the background and a clock will appear on the LCD.  
+Congratulations!  The linux kernel will now output keycodes for all your extra keys.
+
+.SH "Using the keys in X11"
+Current versions of the Xorg Xserver dont have support for the extra keys that g15daemon provides.  This support will be available in the next release of Xorg (7.2).
+
+For now, if you want access to the extra keys for hotkey support in X11, you need to run the xmodmaprc script on each start of X.  This script is available in the contrib folder (if g15daemon is installed in the default location, the contrib folder is in /usr/share/doc/g15daemon\-${VERSION}/contrib 
+
+Depending on your linux distribution, copying the xmodmaprc file (or pasting the text below) into ~/.Xmodmap may be all that's required.
+
+.SH "Xmodmaprc file"
+Copy the following into ~/.Xmodmap (depending on your distribution) for X11 to recognise all extra G15 keys:
+
+\-\- cut here \-\-
+.br
+keycode  93 = XF86Launch1
+.br
+keycode 129 = XF86Launch8
+.br
+keycode 130 = XF86Launch9
+.br
+keycode 131 = XF86Launch2
+.br
+keycode 132 = XF86Phone
+.br
+keycode 133 = XF86Messenger
+.br
+keycode 136 = XF86LaunchD
+.br
+keycode 137 = XF86Support
+.br
+keycode 138 = XF86Word
+.br
+keycode 143 = XF86LaunchF
+.br
+keycode 144 = XF86AudioPrev
+.br
+keycode 150 = XF86LogOff
+.br
+keycode 152 = XF86Launch5
+.br
+keycode 153 = XF86AudioNext
+.br
+keycode 160 = XF86AudioMute
+.br
+keycode 161 = XF86Travel
+.br
+keycode 162 = XF86AudioPlay
+.br
+keycode 163 = XF86Spell
+.br
+keycode 164 = XF86AudioStop
+.br
+keycode 170 = XF86VendorHome
+.br
+keycode 174 = XF86AudioLowerVolume
+.br
+keycode 176 = XF86AudioRaiseVolume
+.br
+keycode 177 = XF86Launch4
+.br
+keycode 178 = XF86HomePage
+.br
+keycode 182 = XF86Away
+.br
+keycode 183 = XF86WebCam
+.br
+keycode 184 = XF86Launch0
+.br
+keycode 188 = XF86Music
+.br
+keycode 190 = XF86Launch6
+.br
+keycode 194 = XF86Forward
+.br
+keycode 195 = XF86Send
+.br
+keycode 205 = XF86Calendar
+.br
+keycode 208 = XF86Launch7
+.br
+keycode 209 = XF86LaunchB
+.br
+keycode 210 = XF86LaunchC
+.br
+keycode 215 = XF86Save
+.br
+keycode 219 = XF86WWW
+.br
+keycode 220 = XF86LaunchE
+.br
+keycode 223 = XF86Sleep
+.br
+keycode 228 = XF86Pictures
+.br
+keycode 231 = XF86LaunchA
+.br
+keycode 236 = XF86Mail
+.br
+keycode 237 = XF86AudioMedia
+.br
+keycode 246 = XF86iTouch
+.br
+keycode 247 = XF86Launch3
+.br
+keycode 249 = XF86ToDoList
+.br
+keycode 251 = XF86Calculater
+.br
+\-\- end cutting \-\-
+.SH "AUTHORS"
+The latest release of g15daemon is available at
+.P
+http://g15daemon.sourceforge.net
+.P
+G15daemon was written by Mike Lampard [e-mail] and uses the libg15 library by Philip Lawatsch and Anthony J. Mirabella of the g15tools project. (g15tools.sourceforge.net)
+.P
+The Python bindings for libg15daemon_client were written by Sven Ludwig.
+.P
+Many thanks to everyone who has assisted in reporting bugs, misfeatures and made feature requests.
+
+An up to date list of all authors is available in the AUTHORS file distributed in the source.
+
+.SH "LICENSE"
+G15daemon, libg15daemon_client and other sourcecode in this package are licensed under the GPL (General Public License), version 2 or later.  Details on this license are available in the LICENSE document in the root directory of the source package, and at http://www.fsf.org
+
+

=== added file '.pc/01-remove-x11-setup-from-man.diff/Documentation/g15daemon_client_devel.3'
--- .pc/01-remove-x11-setup-from-man.diff/Documentation/g15daemon_client_devel.3	1970-01-01 00:00:00 +0000
+++ .pc/01-remove-x11-setup-from-man.diff/Documentation/g15daemon_client_devel.3	2015-05-21 10:27:39 +0000
@@ -0,0 +1,220 @@
+.TH "G15daemon Client Development" "" "1.0" "G15Daemon" ""
+.SH "NAME" g15daemon_client \- G15Daemon Server / Client communication for g15daemon.
+.SH "SYNOPSIS"
+#include <libg15.h>
+.br 
+#include <g15daemon_client.h>
+
+link with
+
+\-lg15daemon_client
+
+int new_g15_screen(int screentype);
+.br 
+int g15_close_screen(int sock);
+.br 
+int g15_send(int sock, char *buf, unsigned int len);
+.br 
+int g15_recv(int sock, char *buf, unsigned int len);
+.br 
+int g15_send_cmd (int sock, unsigned char command, unsigned char value);
+.br
+.SH "G15Daemon Server / Client communication"
+G15Daemon uses INET sockets to talk to its clients, listening on localhost port 15550 for connection requests.  Once connected, the server sends the text string "G15 daemon HELLO" to confirm to the client that it is a valid g15daemon process, creates a new screen, and waits for LCD buffers or commands to be sent from the client.  Clients are able to create multiple screens simply by opening more socket connections to the server process.  If the socket is closed or the client exits, all LCD buffers and the screen associated with that socket are automatically destroyed.
+
+Clients wishing to display on the LCD must send entire screens in the format of their choice.  Currently partial screen updates (icons etc) are not supported.
+
+G15Daemon commands are sent to the daemon via the OOB (out\-of\-band) messagetype, replies are sent inband back to the client.
+
+.SH "int new_g15_screen(int screentype)"
+Opens a new connection and returns a network socket for use.  Creates a screen with one of the following pixel formats defined in g15daemon_client.h:
+
+G15_PIXELBUF:	this buffer must be exactly 6880 bytes, and uses 1 byte per pixel.
+
+G15_TEXTBUF:	currently ignored by the daemon.  
+
+G15_WBMPBUF:	this is a packed pixel buffer in WBMP format with 8 pixels per byte. Useful for perl programmers using the GD:: and G15Daemon.pm (see lang_bindings directory) perl modules.
+
+G15_G15RBUF:	another packed pixel buffer type, also with 8 pixels/byte, and is the native libg15render format.
+
+Example of use:
+
+int screen_fd = new_g15_screen( G15_WBMPBUF );
+
+
+
+
+
+.SH "int g15_close_screen (int screen_fd)"
+Simply closes a socket previously opened with new_g15_screen().  The daemon will automatically clean up any buffers and remove the LCD screen from the display list.
+
+Returns 0 if successful, or errno if there was an error.
+
+Example:
+
+int retval = 0;
+int screen_fd = new_g15_screen( G15_WBMPBUF );
+
+... do processing and display here ...
+
+retval = g15_close_screen( screen_fd );
+
+.SH "int g15_send (int sock, char *buf, unsigned int len)"
+A simple wrapper around send() to ensure that all 'len' bytes of data is sent to the daemon.  It simply uses poll() to block until the entire message is sent.
+
+Returns 0 on success, \-1 if the send failed due to timeout or socket error.
+
+
+
+.SH "int g15_recv (int sock, char *buf, unsigned int len)"
+A simple wrapper around recv() to ensure that all 'len' bytes of data are received from the daemon.  It simply uses poll() to block until the entire message is received.
+
+Returns 0 on success, \-1 if the recv failed due to timeout or socket error.
+
+.SH "int g15_send_cmd ( int sock, unsigned char command, unsigned char value)"
+Sends a command to the daemon (possible commands are listed below).  Returns 0 or the return value of the command on success, \-1 on failure.
+
+See examples for usage.
+
+
+.SH "G15Daemon Command Types"
+.P
+Commands and requests to the daemon are sent via OOB data packets.  Changes to the backlight and mkey state will only affect the calling client.  The following commands are supported as defined in g15daemon_client.h:
+
+.IP "G15DAEMON_KEY_HANDLER"
+Requests that all M and G key presses are sent to this client.  All keys are packed into an unsigned int, and sent to the client inband when a key is pressed.
+
+.IP "G15DAEMON_MKEYLEDS"
+Sets the M key LED state.  In order to change LED state, each LED that is to be turned on is OR'd with the command byte.  See libg15.h for values.  For examples see the end of this document.
+
+.IP "G15DAEMON_BACKLIGHT"
+Sets the LCD Backlight brightness.  Brightness level (0|1|2) is OR'd with the command byte.  For examples see the end of this document.
+
+.IP "G15DAEMON_CONTRAST"
+Sets the LCD contrast.  Contrast level (0|1|2) is OR'd with the command byte.  For examples see the end of this document.
+
+.IP "G15DAEMON_GET_KEYSTATE"
+Requests a packet containing the current keystate.  The daemon will return an unsigned int containing any keys pressed.  See libg15.h for details on key values, and lcdclient_test.c in the source distribution for an example.
+
+.IP "G15DAEMON_SWITCH_PRIORITIES"
+Toggles the client's LCD screen to/from the front.  Clients can check their foreground/background state with the following:
+
+.IP "G15DAEMON_IS_FOREGROUND"
+On reciept of this command, G15Daemon will send a 1 byte packet back with the value 1 if the client is foreground, or 0 if not.
+
+.IP "G15DAEMON_IS_USER_SELECTED"
+On reciept of this command, G15daemon will return a byte indicating if the user selected the client be foreground or background.
+
+.SH "EXAMPLES"
+Below is a completely nonsensical client which (poorly) demonstrates the usage of most of the commands.
+
+\-\-\- Cut here \-\-\-
+.P
+#include <stdio.h>
+.br 
+#include <stdlib.h>
+.br 
+#include <string.h>
+.br 
+#include <sys/types.h>
+.br 
+#include <sys/socket.h>
+.br 
+#include <errno.h>
+.br 
+#include <poll.h>
+.br 
+#include <g15daemon_client.h>
+.br 
+#include <libg15.h>
+.br 
+.P
+/* #define TEST_KEYHANDLER */
+
+int main(int argc, char *argv[])
+{
+    int g15screen_fd, retval;
+    char lcdbuffer[6880];
+    unsigned int keystate;
+    char msgbuf[256];
+    int foo = 0;
+    
+    if((g15screen_fd = new_g15_screen(G15_PIXELBUF))<0){
+        printf("Sorry, cant connect to the G15daemon\n");
+        return 5;
+    }else
+        printf("Connected to g15daemon.  sending image\n");
+
+        if(argc<2)
+            retval = g15_send(g15screen_fd,(char*)logo_data,6880);
+        else {
+            memset(lcdbuffer,0,6880);
+            memset(lcdbuffer,1,6880/2);
+            retval = g15_send(g15screen_fd,(char*)lcdbuffer,6880);
+        }
+
+        printf("checking key status \- press G1 to exit\n",retval);
+        
+        while(1){
+            keystate = 0;
+            int foo;
+
+            keystate = g15_send_cmd (g15screen_fd, G15DAEMON_GET_KEYSTATE, foo);
+            if(keystate)
+                printf("keystate = %i\n",keystate);
+
+            if(keystate & G15_KEY_G1) //G1 key.  See libg15.h for details on key values.
+                break;
+
+            /* G2,G3 & G4 change LCD backlight */
+            if(keystate & G15_KEY_G2){
+                retval = g15_send_cmd (g15screen_fd, G15DAEMON_BACKLIGHT, G15_BRIGHTNESS_DARK);
+            }
+            if(keystate & G15_KEY_G3){
+                retval = g15_send_cmd (g15screen_fd, G15DAEMON_BACKLIGHT, G15_BRIGHTNESS_MEDIUM);
+            }
+            if(keystate & G15_KEY_G4){
+                retval = g15_send_cmd (g15screen_fd, G15DAEMON_BACKLIGHT, G15_BRIGHTNESS_BRIGHT);
+            }
+
+            /* is this client in the foreground?? */
+            retval = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
+
+            if(retval)
+              printf("Hey, we are in the foreground, Doc\n");
+            else
+              printf("What dastardly wabbit put me in the background?\n");
+
+            retval = g15_send_cmd (g15screen_fd, G15DAEMON_IS_USER_SELECTED, foo);
+            if(retval)
+              printf("You wanted me in the foreground, right Doc?\n");
+            else
+              printf("You dastardly wabbit !\n");
+            
+            if(retval){ /* we've been backgrounded! */
+                sleep(2); /* remain in the background for a bit */
+                retval = g15_send_cmd (g15screen_fd, G15DAEMON_SWITCH_PRIORITIES, foo);
+                sleep(2); /* switch to foreground */
+                retval = g15_send_cmd (g15screen_fd, G15DAEMON_SWITCH_PRIORITIES, foo);
+            }
+                       
+            usleep(500);
+#ifdef TEST_KEYHANDLER
+            /* ok.. request that all G&M keys are passed to us.. */
+            retval = g15_send_cmd (g15screen_fd, G15DAEMON_KEY_HANDLER, foo);
+            
+            while(1){
+                printf("waiting on keystate\n");
+                keystate=0;
+                retval = recv(g15screen_fd, &keystate , sizeof(keystate),0);
+                if(keystate)
+                  printf("Recieved %i as keystate",keystate);
+            }
+#endif
+        }
+        g15_close_screen(g15screen_fd);
+        return 0;
+}
+
+\-\- end cutting \-\-
+

=== added directory '.pc/02-better-screenshort-creation.diff'
=== added directory '.pc/02-better-screenshort-creation.diff/g15daemon'
=== added file '.pc/02-better-screenshort-creation.diff/g15daemon/utility_funcs.c'
--- .pc/02-better-screenshort-creation.diff/g15daemon/utility_funcs.c	1970-01-01 00:00:00 +0000
+++ .pc/02-better-screenshort-creation.diff/g15daemon/utility_funcs.c	2015-05-21 10:27:39 +0000
@@ -0,0 +1,688 @@
+/*
+    This file is part of g15daemon.
+
+    g15daemon 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.
+
+    g15daemon 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 g15daemon; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    
+    (c) 2006-2008 Mike Lampard, Philip Lawatsch, and others
+
+    $Revision: 449 $ -  $Date: 2008-01-24 17:42:07 +1030 (Thu, 24 Jan 2008) $ $Author: mlampard $
+        
+    This daemon listens on localhost port 15550 for client connections,
+    and arbitrates LCD display.  Allows for multiple simultaneous clients.
+    Client screens can be cycled through by pressing the 'L1' key.
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <ctype.h>
+
+#include <sys/time.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "g15daemon.h"
+#include <libg15.h>
+#include <stdarg.h>
+#include <libg15render.h>
+
+extern unsigned int g15daemon_debug;
+extern volatile int leaving;
+#define G15DAEMON_PIDFILE "/var/run/g15daemon.pid"
+
+pthread_cond_t lcd_refresh = PTHREAD_COND_INITIALIZER;
+
+
+/* if no exitfunc or eventhandler, member should be NULL */
+const plugin_info_t generic_info[] = {
+    /* TYPE, name, initfunc, updatefreq, exitfunc, eventhandler */
+    {G15_PLUGIN_LCD_CLIENT, "BackwardCompatible", NULL, 0, NULL, (void*)internal_generic_eventhandler},
+    {G15_PLUGIN_NONE,        ""          , NULL,     0,   NULL, NULL}
+};
+
+/* handy function from xine_utils.c */
+void *g15daemon_xmalloc(size_t size) {
+    void *ptr;
+
+    /* prevent xmalloc(0) of possibly returning NULL */
+    if( !size )
+        size++;
+
+    if((ptr = calloc(1, size)) == NULL) {
+        g15daemon_log(LOG_WARNING, "g15_xmalloc() failed: %s.\n", strerror(errno));
+        return NULL;
+    }
+    return ptr;
+}
+
+static int refresh_pending=0;
+void g15daemon_init_refresh() {
+  pthread_condattr_t attr;
+  pthread_cond_init(&lcd_refresh, &attr);
+}
+
+void g15daemon_send_refresh(lcd_t *lcd) {
+    if(lcd==lcd->masterlist->current->lcd||lcd->state_changed) {
+      pthread_cond_broadcast(&lcd_refresh);
+      refresh_pending++;
+    }
+}
+
+void g15daemon_wait_refresh() {
+    pthread_mutex_t dummy_mutex;
+    struct timespec timeout;
+    int retval;
+    if(refresh_pending<1) {
+      /* Create a dummy mutex which doesn't unlock for sure while waiting. */
+      pthread_mutex_init(&dummy_mutex, NULL);
+      pthread_mutex_lock(&dummy_mutex);
+start:
+      time(&timeout.tv_sec);
+      timeout.tv_sec += 1;
+      timeout.tv_nsec = 0L;
+
+      retval=pthread_cond_timedwait(&lcd_refresh, &dummy_mutex, &timeout);
+      if(!leaving && retval == ETIMEDOUT)
+        goto start;
+      pthread_mutex_unlock(&dummy_mutex);
+      pthread_mutex_destroy(&dummy_mutex);
+    }
+    refresh_pending--;
+}
+
+void g15daemon_quit_refresh() {
+    pthread_cond_destroy(&lcd_refresh);
+}
+
+int uf_return_running(){
+    int fd;
+    char pidtxt[128];
+    int pid;
+    int l;
+    
+    if ((fd = open(G15DAEMON_PIDFILE, O_RDWR, 0644)) < 0) {
+            return -1;
+    }
+    if((l = read(fd,pidtxt,sizeof(pidtxt)-1)) < 0) {
+        unlink (G15DAEMON_PIDFILE);
+        close(fd);
+        return -1;
+    }
+    if((pid = atoi(pidtxt)) <= 0) {
+        g15daemon_log(LOG_ERR,"pidfile corrupt");
+        unlink(G15DAEMON_PIDFILE);
+        close(fd);
+        return -1;
+    }
+    if((kill(pid,0) != 0) && errno != EPERM ) {
+        g15daemon_log(LOG_ERR,"Process died - removing pidfile");
+        unlink(G15DAEMON_PIDFILE);
+        close(fd);
+        return -1;
+    }
+    
+    return pid;
+    
+}
+
+int uf_create_pidfile() {
+    
+    char pidtxt[128];
+    size_t l;
+    int fd;
+    
+    if(!uf_return_running() &&  (fd = open(G15DAEMON_PIDFILE, O_CREAT|O_RDWR|O_EXCL, 0644)) < 0) {
+        g15daemon_log(LOG_ERR,"previous G15Daemon process died.  removing pidfile");
+        unlink(G15DAEMON_PIDFILE);
+    }
+    if ((fd = open(G15DAEMON_PIDFILE, O_CREAT|O_RDWR|O_EXCL, 0644)) < 0) {
+        return 1;
+    }
+    
+    snprintf(pidtxt, sizeof(pidtxt), "%lu\n", (unsigned long) getpid());
+
+    if (write(fd, pidtxt, l = strlen(pidtxt)) != l) {
+        g15daemon_log(LOG_WARNING, "write(): %s", strerror(errno));
+        unlink(G15DAEMON_PIDFILE);
+    }
+    
+    if(fd>0) {
+        close(fd);
+        return 0;
+    }
+    return 1;
+}
+
+
+/* syslog wrapper */
+int g15daemon_log (int priority, const char *fmt, ...) {
+   va_list argp;
+   va_start (argp, fmt);
+   int real_prio=0;
+   
+   switch(g15daemon_debug) {
+     case 0:
+     case 1:
+      real_prio = LOG_WARNING;
+      break;
+     case 2:
+      real_prio = LOG_INFO;
+      break;
+     default:
+      real_prio = LOG_DEBUG;
+   }
+
+   if(real_prio>=priority) {
+    if(g15daemon_debug == 0) {
+     vsyslog(priority, fmt, argp);
+    } else {
+     vfprintf(stderr,fmt,argp);
+     fprintf(stderr,"\n");
+    }
+   }
+   va_end (argp);
+   
+   return 0;
+}
+
+/* takes a 6880 byte (1byte==1pixel) buffer and packs it into libg15 format. */
+void g15daemon_convert_buf(lcd_t *lcd, unsigned char * orig_buf)
+{
+    unsigned int x,y,val;
+    for(x=0;x<160;x++)
+        for(y=0;y<43;y++)
+	  {
+		unsigned int pixel_offset = y * LCD_WIDTH + x;
+    		unsigned int byte_offset = pixel_offset / 8;
+    		unsigned int bit_offset = 7-(pixel_offset % 8);
+
+		val = orig_buf[x+(y*160)];
+
+    		if (val)
+        		lcd->buf[byte_offset] = lcd->buf[byte_offset] | 1 << bit_offset;
+    		else
+        		lcd->buf[byte_offset] = lcd->buf[byte_offset]  &  ~(1 << bit_offset);
+	  }
+}
+
+/* wrap the libg15 functions */
+int uf_write_buf_to_g15(lcd_t *lcd)
+{
+    int retval = 0;
+#ifdef LIBUSB_BLOCKS
+    retval = writePixmapToLCD(lcd->buf);
+#else
+    pthread_mutex_lock(&g15lib_mutex);
+    retval = writePixmapToLCD(lcd->buf);
+    pthread_mutex_unlock(&g15lib_mutex);
+#endif    
+    return retval;
+}
+
+int uf_read_keypresses(unsigned int *keypresses, unsigned int timeout) 
+{
+    int retval=0;
+#ifdef LIBUSB_BLOCKS
+    retval = getPressedKeys(keypresses, timeout);
+#else
+    pthread_mutex_lock(&g15lib_mutex);
+    retval = getPressedKeys(keypresses, timeout);
+    pthread_mutex_unlock(&g15lib_mutex);
+#endif    
+    return retval;
+}
+
+/* Sleep routine (hackish). */
+void g15daemon_sleep(int seconds) {
+    pthread_mutex_t dummy_mutex;
+    static pthread_cond_t dummy_cond = PTHREAD_COND_INITIALIZER;
+    struct timespec timeout;
+
+    /* Create a dummy mutex which doesn't unlock for sure while waiting. */
+    pthread_mutex_init(&dummy_mutex, NULL);
+    pthread_mutex_lock(&dummy_mutex);
+
+    timeout.tv_sec = time(NULL) + seconds;
+    timeout.tv_nsec = 0;
+
+    pthread_cond_timedwait(&dummy_cond, &dummy_mutex, &timeout);
+
+    /*    pthread_cond_destroy(&dummy_cond); */
+    pthread_mutex_unlock(&dummy_mutex);
+    pthread_mutex_destroy(&dummy_mutex);
+}
+
+/* microsecond sleep routine. */
+int g15daemon_usleep(int useconds) {
+    
+    struct timeval timeout;
+    if(useconds < 10000)
+      useconds = 10000;
+    timeout.tv_sec = useconds / 1000000;
+    timeout.tv_usec = useconds % 1000000;
+    return select (0,0,0,0,&timeout);
+}
+
+/* millisecond sleep routine. */
+int g15daemon_msleep(int milliseconds) {
+    
+    return g15daemon_usleep(milliseconds*1000);
+}
+
+
+unsigned int g15daemon_gettime_ms(){
+    struct timeval tv;
+    gettimeofday(&tv,NULL);
+    return (tv.tv_sec*1000+tv.tv_usec/1000);
+}
+
+/* generic event handler used unless overridden (only loading a plugin will override currently)*/
+int internal_generic_eventhandler(plugin_event_t *event) {
+    
+    lcd_t *lcd = (lcd_t*) event->lcd;
+    
+    switch (event->event)
+    {
+        case G15_EVENT_KEYPRESS: {
+            if(lcd->g15plugin->plugin_handle){ /* loadable plugin */
+                 /* plugin had null for eventhandler therefore doesnt want events.. throw them away */
+            }
+        }
+        break;
+        case G15_EVENT_VISIBILITY_CHANGED:
+          break;
+        default:
+          break;
+    }
+    return G15_PLUGIN_OK;
+}
+
+
+/* free all memory used by the config subsystem */
+void uf_conf_free(g15daemon_t *list)
+{
+    config_section_t *section=list->config->sections;
+    config_items_t *tmpitem=NULL;
+    config_section_t *tmpsection=section;
+    
+    while(tmpsection!=NULL){
+        tmpitem=section->items;
+        
+        if(section->sectionname){
+            free(section->sectionname);
+            while(section->items!=NULL){
+                if(tmpitem->key!=NULL) 
+                    free(tmpitem->key);
+                if(tmpitem->value!=NULL)
+                    free(tmpitem->value);
+                tmpitem=section->items->next;
+                free(section->items);
+                section->items=tmpitem;
+            }
+        }
+        tmpsection=section->next;
+        free(section);
+        section=tmpsection;
+    }
+    free(section);
+    free(list->config);
+}
+
+/* write the config file with all keys/sections */
+int uf_conf_write(g15daemon_t *list,char *filename)
+{
+    int config_fd=-1;
+    config_section_t *foo=list->config->sections;
+    config_items_t * item=NULL;
+    char line[1024];
+    
+    config_fd = open(filename,O_CREAT|O_RDWR|O_TRUNC);
+    if(config_fd){
+    snprintf(line,1024,"# G15Daemon Configuration File\n# any items entered before a [section] header\n# will be in the Global config space\n# comments you wish to keep should start with a semicolon';'\n");
+    write(config_fd,line,strlen(line));
+    while(foo!=NULL){
+        item=foo->items;
+        memset(line,0,1024);
+        if(foo->sectionname!=NULL){
+            snprintf(line,1024,"\n[%s]\n",foo->sectionname);
+            write(config_fd,line,strlen(line));
+            while(item!=NULL){
+                memset(line,0,1024);
+                if(item->key!=NULL){
+                    if(item->key[0]==';') // comment
+                        snprintf(line,1024,"%s\n",item->key);
+                    else
+                        snprintf(line,1024,"%s: %s\n",item->key, item->value);
+                    write(config_fd,line,strlen(line));
+                }
+                item=item->next;
+            }
+        }
+        foo=foo->next;
+    }
+    close(config_fd);
+    return 0;
+    }
+    return -1;
+}
+
+/* search the list for valid section name return pointer to section, or NULL otherwise */
+config_section_t* uf_search_confsection(g15daemon_t *list,char *sectionname){
+    config_section_t *section=list->config->sections;
+    
+    while(section!=NULL){
+        if(0==strcmp((char*)section->sectionname,(char*)sectionname))
+            break;
+        section=section->next;
+    }
+    return section;
+}
+
+/* search the list for valid key called "key" in section named "section" return pointer to item or NULL */
+config_items_t* uf_search_confitem(config_section_t *section, char *key){
+    
+    config_items_t * item=NULL;
+    
+    if(section!=NULL){
+        item=section->items;
+        while(item!=NULL){
+            if(0==strcmp((char*)item->key,(char*)key))
+                break;
+            item=item->next;
+        }
+    }
+    return item;
+}
+
+
+/* return pointer to section, or create a new section if it doesnt exist */
+config_section_t *g15daemon_cfg_load_section(g15daemon_t *masterlist,char *name) {
+    
+    config_section_t *new = NULL;
+    if((new=uf_search_confsection(masterlist,name))!=NULL)
+        return new;
+    new = g15daemon_xmalloc(sizeof(config_section_t));
+    new->head = new;
+    new->next = NULL;;
+    new->sectionname=strdup(name);
+    if(!masterlist->config->sections){
+        masterlist->config->sections=new;
+        masterlist->config->sections->head = new;
+    } else {
+        masterlist->config->sections->head->next=new;
+        masterlist->config->sections->head = new;
+    }
+    return new;
+}
+
+/* cleanup whitespace */
+char * uf_remove_whitespace(char *str){
+    int z=0;
+    if(str==NULL)
+        str=strdup(" ");
+    while(isspace(str[z])&&str[z])
+        z++;
+    str+=z;
+    return str;
+}
+
+/* add a new key, or update the value of an already existing key, or return -1 if section doesnt exist */
+int g15daemon_cfg_write_string(config_section_t *section, char *key, char *val){
+    
+    config_items_t *new = NULL;
+
+    if(section==NULL)
+        return -1;
+    
+    if((uf_search_confitem(section, key))){
+        free(new);
+        new=uf_search_confitem(section, key);
+        new->value=strdup(val);
+    }else{
+        new=g15daemon_xmalloc(sizeof(config_items_t));
+        new->head=new;
+        new->next=NULL;
+        
+        new->key=strdup(key);
+        new->value=strdup(val);
+        if(!section->items){
+            new->prev=NULL;
+            section->items=new;
+            section->items->head=new;
+        }else{
+            new->prev=section->items->head;
+            section->items->head->next=new;
+            section->items->head=new;
+        }
+    }
+    return 0;
+}
+
+/* remoe a key/value pair from named section */
+int g15daemon_cfg_remove_key(config_section_t *section, char *key){
+    
+    config_items_t *new = NULL;
+    config_items_t *next = NULL;
+    config_items_t *prev = NULL;
+    if(section==NULL)
+        return -1;
+    
+    if((uf_search_confitem(section, key))){
+        new=uf_search_confitem(section, key);
+        prev=new->prev;
+        next=new->next;
+        if(prev){
+            prev->next=new->next;
+        }else{
+             if(!next) {
+                    free(section->items);
+                    section->items=NULL;
+                }
+                else
+                    section->items=next;
+            }
+
+        if(new->head==new){
+            if(prev){
+                prev->head = prev;
+                section->items->head=prev;
+            }
+            if(!prev){
+                if(!next) {
+                    free(section->items);
+                    section->items=NULL;
+                }
+            }
+        }
+        if(next){
+            if(prev)
+            	next->prev=prev;
+            else
+                next->prev=NULL;
+        }
+        free(new->key);
+        free(new->value);
+        free(new);
+    }
+    return 0;
+}
+
+int g15daemon_cfg_write_int(config_section_t *section, char *key, int val) {
+    char tmp[1024];
+    snprintf(tmp,1024,"%i",val);
+    return g15daemon_cfg_write_string(section, key, tmp);
+}
+
+int g15daemon_cfg_write_float(config_section_t *section, char *key, double val) {
+    char tmp[1024];
+    snprintf(tmp,1024,"%f",val);
+    return g15daemon_cfg_write_string(section, key, tmp);
+}
+
+/* simply write value as On or Off depending on whether val>0 */
+int g15daemon_cfg_write_bool(config_section_t *section, char *key, unsigned int val) {
+    char tmp[1024];
+    snprintf(tmp,1024,"%s",val?"On":"Off");
+    return g15daemon_cfg_write_string(section, key, tmp);
+}
+
+/* the config read functions will either return a value from the config file, or the default value, which will be written to the config file if the key doesnt exist */
+
+/* return bool as int from key in sectionname */
+int g15daemon_cfg_read_bool(config_section_t *section, char *key, int defaultval) {
+    
+    int retval=0;
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+        retval = 1^retval?(strncmp(item->value,"On",2)==0):1;
+           return retval;
+    }
+    g15daemon_cfg_write_bool(section, key, defaultval);
+    return defaultval;
+}
+
+/* return int from key in sectionname */
+int g15daemon_cfg_read_int(config_section_t *section, char *key, int defaultval) {
+    
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+           return atoi(item->value);
+    }
+    g15daemon_cfg_write_int(section, key, defaultval);
+    return defaultval;
+}
+
+/* return float from key in sectionname */
+double g15daemon_cfg_read_float(config_section_t *section, char *key, double defaultval) {
+    
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+           return atof(item->value);
+    }
+    g15daemon_cfg_write_float(section, key, defaultval);
+    return defaultval;
+}
+
+/* return string value from key in sectionname */
+char* g15daemon_cfg_read_string(config_section_t *section, char *key, char *defaultval) {
+    
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+           return item->value;
+    }
+    g15daemon_cfg_write_string(section, key, defaultval);
+    return defaultval;
+}
+
+
+int uf_conf_open(g15daemon_t *list, char *filename) {
+
+    char *buffer, *lines;
+    int config_fd=-1;
+    char *sect;
+    char *start;
+    char *bar = NULL;
+    int i;
+    struct stat stats;
+	
+    list->config=g15daemon_xmalloc(sizeof(configfile_t));
+    list->config->sections=NULL;
+
+    if (lstat(filename, &stats) == -1)
+        return -1;
+    if (!(config_fd = open(filename, O_RDWR)))
+        return -1;
+
+    buffer = g15daemon_xmalloc(stats.st_size + 1);
+        
+    if (read(config_fd, buffer, stats.st_size) != stats.st_size)
+    {
+        free(buffer);
+        close(config_fd);
+        return -1;
+    }
+    close(config_fd);
+    buffer[stats.st_size] = '\0';
+        
+    lines=strtok_r(buffer,"\n",&bar);
+    config_section_t *section=NULL;
+    while(lines!=NULL){
+        sect=strdup(lines);
+        
+        i=0;
+        while(isspace(sect[i])){
+            i++;
+        }
+        start=sect+i;
+        if(start[0]=='#'){
+	   /* header - ignore */
+           /* comments start with ; and can be produced like so:
+             g15daemon_cfg_write_string(noload_cfg,"; Plugins in this section will not be loaded on start","");
+             the value parameter must not be used.
+           */
+        } else if(strrchr(start,']')) { /* section title */
+            char sectiontitle[1024];
+            memset(sectiontitle,0,1024);
+            strncpy(sectiontitle,start+1,strlen(start)-2);
+            section = g15daemon_cfg_load_section(list,sectiontitle);
+        }else{
+            /*section keys */
+            if(section==NULL){
+                /* create an internal section "Global" which is the default for items not under a [section] header */
+                section=g15daemon_cfg_load_section(list,"Global");
+            }
+            char *foo=NULL;
+            char *key = uf_remove_whitespace( strtok_r(start,":=",&foo) );
+            char *val = uf_remove_whitespace( strtok_r(NULL,":=", &foo) );
+            
+            g15daemon_cfg_write_string(section,key,val);
+        }        
+        free(sect);
+        lines=strtok_r(NULL,"\n",&bar);
+    }
+
+    free(buffer);
+    return 0;
+}
+
+int uf_screendump_pbm(unsigned char *buffer,char *filename) {
+    FILE *f;
+    int x,y;
+    #define WIDTH 40
+    g15canvas *canvas=g15daemon_xmalloc(sizeof(g15canvas));
+    memcpy(canvas->buffer,buffer,LCD_BUFSIZE);
+    f = fopen(filename,"w+");
+    fprintf(f,"P1\n160 43\n");
+    fprintf(f,"# G15 screendump - %s\n\n",filename);
+    for(y=0;y<43;y++)
+      for(x=0;x<160;x++) {
+        fprintf(f,"%i",g15r_getPixel(canvas,x,y));
+            if(x%WIDTH==WIDTH-1)
+              fprintf(f,"\n");
+        }
+
+        fclose(f);
+    free(canvas);
+    return 0;
+}
+

=== added directory '.pc/03-change-syslog-facility.diff'
=== added directory '.pc/03-change-syslog-facility.diff/g15daemon'
=== added file '.pc/03-change-syslog-facility.diff/g15daemon/main.c'
--- .pc/03-change-syslog-facility.diff/g15daemon/main.c	1970-01-01 00:00:00 +0000
+++ .pc/03-change-syslog-facility.diff/g15daemon/main.c	2015-05-21 10:27:39 +0000
@@ -0,0 +1,580 @@
+/*
+    This file is part of g15daemon.
+
+    g15daemon 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.
+
+    g15daemon 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 g15daemon; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    
+    (c) 2006-2008 Mike Lampard, Philip Lawatsch, and others
+    
+    $Revision: 457 $ -  $Date: 2008-01-31 15:32:46 +1030 (Thu, 31 Jan 2008) $ $Author: mlampard $
+    
+    This daemon listens on localhost port 15550 for client connections,
+    and arbitrates LCD display.  Allows for multiple simultaneous clients.
+    Client screens can be cycled through by pressing the 'L1' key.
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <ctype.h>
+
+#include <config.h>
+#include <libg15.h>
+#include <libg15render.h>
+#include "g15daemon.h"
+
+#ifndef LIBG15_VERSION
+#define LIBG15_VERSION 1000
+#endif
+
+/* all threads will exit if leaving >0 */
+volatile int leaving = 0;
+int keyboard_backlight_off_onexit = 0;
+unsigned int g15daemon_debug = 0;
+unsigned int cycle_key;
+unsigned int client_handles_keys = 0;
+static unsigned int set_backlight = 0;
+struct lcd_t *keyhandler = NULL;
+
+static int loaded_plugins = 0;
+
+/* send event to foreground client's eventlistener */
+int g15daemon_send_event(void *caller, unsigned int event, unsigned long value)
+{
+    switch(event) {
+        case G15_EVENT_KEYPRESS: {
+            static unsigned long lastkeys;
+            if(!(value & cycle_key) && !(lastkeys & cycle_key)){
+                lcd_t *lcd = (lcd_t*)caller;
+ 
+                if(!lcd->g15plugin->info)
+                  break;
+ 
+                int *(*plugin_listener)(plugin_event_t *newevent) = (void*)lcd->g15plugin->info->event_handler;
+                plugin_event_t *newevent=g15daemon_xmalloc(sizeof(plugin_event_t));
+                newevent->event = event;
+                newevent->value = value;
+                newevent->lcd = lcd;
+                (*plugin_listener)((void*)newevent);
+        	/* hack - keyboard events are always sent from the foreground even when they aren't 
+                send keypress event to the OS keyboard_handler plugin */
+                if(lcd->masterlist->keyboard_handler != NULL && lcd->masterlist->remote_keyhandler_sock==0) {
+                    int *(*keyboard_handler)(plugin_event_t *newevent) = (void*)lcd->masterlist->keyboard_handler;
+                    (*keyboard_handler)((void*)newevent);
+                }
+                // if we have a remote keyhandler, send the key. FIXME: we should do this from the net plugin
+                if(lcd->masterlist->remote_keyhandler_sock!=0) {
+                          if((send(lcd->masterlist->remote_keyhandler_sock,(void *)&newevent->value,sizeof(newevent->value),0))<0)
+                                              g15daemon_log(LOG_WARNING,"Error in send: %s\n",strerror(errno));
+                }
+                if(value & G15_KEY_LIGHT){ // the backlight key was pressed - maintain user-selected state 
+                  lcd_t *displaying = lcd->masterlist->current->lcd;  
+                  lcd->masterlist->kb_backlight_state++;
+                  lcd->masterlist->kb_backlight_state %= 3;
+                  displaying->backlight_state++;  
+                  displaying->backlight_state %= 3; // limit to 0-2 inclusive 
+                }
+                if(value & G15_KEY_M1 && value & G15_KEY_M3) {
+                  static int scr_num=0;
+                  char filename[128];
+                  lcd_t *displaying = lcd->masterlist->current->lcd;
+                  sprintf(filename,"/tmp/g15daemon-sc-%i.pbm",scr_num);
+                  uf_screendump_pbm(displaying->buf,filename);
+                  scr_num++;
+                }
+                free(newevent);
+            }else{
+                /* hacky attempt to double-time the use of L1, if the key is pressed less than half a second, it cycles the screens.  If held for longer, the key is sent to the application for use instead */
+                lcd_t *lcd = (lcd_t*)caller;
+                g15daemon_t* masterlist = lcd->masterlist;
+                static unsigned int clicktime;
+                
+                if(value & cycle_key) {
+                    clicktime=g15daemon_gettime_ms();
+                }else{
+                    unsigned int unclick=g15daemon_gettime_ms();
+                    if ((unclick-clicktime)<500) {
+                        g15daemon_lcdnode_cycle(masterlist);
+                    }
+                    else 
+                    {
+                        plugin_event_t *clickevent=g15daemon_xmalloc(sizeof(plugin_event_t));
+                        int *(*plugin_listener)(plugin_event_t *clickevent) = (void*)lcd->g15plugin->info->event_handler;
+                        clickevent->event = event;
+                	clickevent->value = value|cycle_key;
+                	clickevent->lcd = lcd;
+                        (*plugin_listener)((void*)clickevent);
+                        clickevent->event = event;
+                	clickevent->value = value&~cycle_key;
+                	clickevent->lcd = lcd;
+                        (*plugin_listener)((void*)clickevent);
+                        free(clickevent);
+                    }
+                }
+            }
+            lastkeys = value;
+            break;
+        }
+        case G15_EVENT_CYCLE_PRIORITY:{
+            lcd_t *lcd = (lcd_t*)caller;
+            g15daemon_t* masterlist = lcd->masterlist;
+            if(value)
+                g15daemon_lcdnode_cycle(masterlist);
+            break;
+        }
+        case G15_EVENT_REQ_PRIORITY: {
+            lcdnode_t *lcdnode=(lcdnode_t*)caller;
+            /* client wants to switch priorities */
+            pthread_mutex_lock(&lcdlist_mutex);
+            if(lcdnode->list->current != lcdnode){
+                lcdnode->last_priority = lcdnode->list->current;
+                lcdnode->list->current = lcdnode;
+            }
+            else {
+                if(lcdnode->list->current == lcdnode->last_priority){
+                    lcdnode->list->current = lcdnode->list->current->prev;
+                } else{
+                    if(lcdnode->last_priority != NULL) {
+                        lcdnode->list->current = lcdnode->last_priority;
+                        lcdnode->last_priority = NULL;
+                    }
+                    else
+                        lcdnode->list->current = lcdnode->list->current->prev;
+                }
+            }
+            pthread_mutex_unlock(&lcdlist_mutex);
+            g15daemon_send_refresh((lcd_t*)lcdnode->list->current->lcd);
+            break;
+        }
+        case G15_EVENT_VISIBILITY_CHANGED:
+            g15daemon_send_refresh((lcd_t*)caller);
+        default: {
+            lcd_t *lcd = (lcd_t*)caller;
+            int *(*plugin_listener)(plugin_event_t *newevent) = (void*)lcd->g15plugin->info->event_handler;
+            plugin_event_t *newevent=g15daemon_xmalloc(sizeof(plugin_event_t));
+            newevent->event = event;
+            newevent->value = value;
+            newevent->lcd = lcd;
+            (*plugin_listener)((void*)newevent);
+            free(newevent);
+        }
+    }
+    return 0;
+}
+
+static void *keyboard_watch_thread(void *lcdlist){
+    
+    g15daemon_t *masterlist = (g15daemon_t*)(lcdlist);
+    
+    unsigned int keypresses = 0;
+    int retval = 0;
+    static int lastkeys = 0;
+
+    while (!leaving) {
+
+        retval = uf_read_keypresses(&keypresses, 20);
+        /* every 2nd packet contains the codes we want.. immediately try again */
+        while (retval == G15_ERROR_TRY_AGAIN){
+            retval = uf_read_keypresses(&keypresses, 20);
+        }
+
+        if(retval == G15_NO_ERROR && lastkeys != keypresses) {
+            g15daemon_send_event(masterlist->current->lcd, 
+                                 G15_EVENT_KEYPRESS, keypresses);
+            lastkeys = keypresses;
+
+        }else if(retval == -ENODEV && LIBG15_VERSION>=1200) {
+          pthread_mutex_lock(&g15lib_mutex);
+          while((retval=re_initLibG15() != G15_NO_ERROR) && !leaving){
+             g15daemon_log(LOG_WARNING,"Keyboard has gone.. Retrying\n");
+             sleep(1);
+          }
+          if(!leaving) { 
+            masterlist->current->lcd->state_changed=1; 
+            g15daemon_send_refresh(masterlist->current->lcd);
+          }
+          pthread_mutex_unlock(&g15lib_mutex); 
+        }
+      g15daemon_msleep(40);
+    }
+    return NULL;
+}
+
+static void *lcd_draw_thread(void *lcdlist){
+
+    g15daemon_t *masterlist = (g15daemon_t*)(lcdlist);
+    /* unsigned int fps = 0; */
+    lcd_t *displaying = masterlist->tail->lcd;
+    memset(displaying->buf,0,1024);
+    static int prev_state=0;
+    g15daemon_sleep(2);
+
+    while (!leaving) {
+        /* wait until a client has updated */
+        g15daemon_wait_refresh();
+
+        pthread_mutex_lock(&lcdlist_mutex);
+        displaying = masterlist->current->lcd;
+                
+        /* monitor 'fps' - due to the TCP protocol, some frames will be bunched up.
+           discard excess to reduce load on the bus */
+        /* fps = 1000 / (g15daemon_gettime_ms() - lastscreentime); */
+        /* if the current screen is less than 20ms from the previous (equivelant to 50fps) delay it */
+        /* this allows a real-world fps of 40fps with no almost frame loss and reduces peak usb bus-load */
+                        
+        g15daemon_log(LOG_DEBUG,"Updating LCD");        
+        uf_write_buf_to_g15(displaying);
+        g15daemon_log(LOG_DEBUG,"LCD Update Complete");
+        
+        if(prev_state!=displaying->backlight_state && set_backlight!=0) {
+              prev_state=displaying->backlight_state;
+              pthread_mutex_lock(&g15lib_mutex);
+              setLCDBrightness(displaying->backlight_state);
+              usleep(5);
+              setLCDBrightness(displaying->backlight_state);
+              setKBBrightness(displaying->backlight_state);
+              pthread_mutex_unlock(&g15lib_mutex);
+        }
+
+        if(displaying->state_changed){
+            pthread_mutex_lock(&g15lib_mutex);
+            setLCDContrast(displaying->contrast_state);
+            if(displaying->masterlist->remote_keyhandler_sock==0) // only allow mled control if the macro recorder isnt running
+              setLEDs(displaying->mkey_state);
+            pthread_mutex_unlock(&g15lib_mutex);
+            displaying->state_changed = 0;
+        }
+            
+        pthread_mutex_unlock(&lcdlist_mutex);
+    }
+    return NULL;
+}
+
+void g15daemon_sighandler(int sig) {
+    switch(sig){
+         case SIGUSR1:
+              keyboard_backlight_off_onexit = 1;
+         case SIGINT:
+         case SIGTERM:
+         case SIGQUIT:
+              leaving = 1;
+               break;
+         case SIGPIPE:
+               break;
+    }
+}
+
+#ifndef HAVE_DAEMON
+/* daemon() is not posix compliant, so we roll our own if needed.*/
+int daemon(int nochdir, int noclose) {
+  pid_t pid;
+  
+  if(nochdir<1)
+    chdir("/");
+  pid = fork();
+
+  switch(pid){
+    case -1:
+     printf("Unable to daemonise!\n");
+     return -1;
+     break;
+    case 0: {
+      umask(0);
+      if(setsid()==-1) {
+       perror("setsid");
+        return -1;
+      }
+      if(noclose<1) {
+        freopen( "/dev/null", "r", stdin);
+        freopen( "/dev/null", "w", stdout);
+        freopen( "/dev/null", "w", stderr);
+      }
+      break;
+    }
+    default:
+      _exit(0);
+  }
+  return 0;
+}
+#endif 
+
+int main (int argc, char *argv[])
+{
+    pid_t daemonpid;
+    int retval;
+    int i;
+    int cycle_cmdline_override=0;
+    struct sigaction new_action;
+    cycle_key = G15_KEY_L1;
+    unsigned char user[256];
+    unsigned int lcdlevel = 1;
+    
+    pthread_t keyboard_thread;
+    pthread_t lcd_thread;
+    memset(user,0,256); 
+
+    for (i=0;i<argc;i++) {
+        char daemonargs[20];
+        memset(daemonargs,0,20);
+        strncpy(daemonargs,argv[i],19);
+        if (!strncmp(daemonargs, "-k",2) || !strncmp(daemonargs, "--kill",6)) {
+                   daemonpid = uf_return_running();
+                   if(daemonpid>0) {
+                       kill(daemonpid,SIGINT);
+                   } else
+                       printf("G15Daemon not running\n");
+ 		   exit(0);
+        }
+        if (!strncmp(daemonargs, "-K",2) || !strncmp(daemonargs, "--KILL",6)) {
+                   daemonpid = uf_return_running();
+                   if(daemonpid>0) {
+                       kill(daemonpid,SIGUSR1);
+                   } else
+                       printf("G15Daemon not running\n");
+ 		   exit(0);
+        }
+        if (!strncmp(daemonargs, "-v",2) || !strncmp(daemonargs, "--version",9)) {
+            float lg15ver = LIBG15_VERSION;
+            printf("G15Daemon version %s - %s\n",VERSION,uf_return_running() >= 0 ?"Loaded & Running":"Not Running");
+            printf("compiled with libg15 version %.3f\n\n",lg15ver/1000);
+            exit(0);
+        }    
+        
+        if (!strncmp(daemonargs, "-h",2) || !strncmp(daemonargs, "--help",6)) {
+            printf("G15Daemon version %s - %s\n",VERSION,uf_return_running() >= 0 ?"Loaded & Running":"Not Running");
+            printf("%s -h (--help) or -k (--kill) or -s (--switch) or -d (--debug) [level] or -v (--version) or -l (--lcdlevel) [0-2] \n\n -k\twill kill a previous incarnation",argv[0]);
+            #ifdef LIBG15_VERSION
+            #if LIBG15_VERSION >= 1200
+            printf("\n -K\tturn off the keyboard backlight on the way out.");
+            #endif
+            #endif
+            printf("\n -h\tshows this help\n -s\tchanges the screen-switch key from L1 to MR (beware)\n -d\tdebug mode - stay in foreground and output all debug messages to STDERR\n -v\tshow version\n -l\tset default LCD backlight level\n");
+            printf(" --set-backlight sets backlight individually for currently shown screen.\n\t\tDefault is to set backlight globally (keyboard default).\n");
+            exit(0);
+        }
+
+        if (!strncmp(daemonargs, "-s",2) || !strncmp(daemonargs, "--switch",8)) {
+            cycle_key = G15_KEY_MR;
+            cycle_cmdline_override=1;
+        }
+
+        if (!strncmp(daemonargs, "--set-backlight",15)) {
+            set_backlight = 1;
+        }
+
+        if (!strncmp(daemonargs, "-d",2) || !strncmp(daemonargs, "--debug",7)) {
+            g15daemon_debug = 1;
+            if((argv[i+1])!=NULL)
+             if(isdigit(argv[i+1][0])){
+              g15daemon_debug = atoi(argv[i+1]);
+              if(g15daemon_debug==0) g15daemon_debug = 1;
+            }
+        }
+        
+        if (!strncmp(daemonargs, "-u",2) || !strncmp(daemonargs, "--user",7)) {
+            if(argv[i+1]!=NULL){
+                strncpy((char*)user,argv[i+1],128);
+                i++;
+            }
+        }
+
+        if (!strncmp(daemonargs, "-l",2) || !strncmp(daemonargs, "--lcdlevel",7)) {
+            if((argv[i+1])!=NULL)
+             if(isdigit(argv[i+1][0])){
+              lcdlevel = atoi(argv[i+1]);
+            }
+        }
+    }
+    if(g15daemon_debug){
+        g15daemon_log(LOG_INFO, "G15Daemon %s Build Date: %s",PACKAGE_VERSION,BUILD_DATE);
+        g15daemon_log(LOG_DEBUG, "Build OS: %s",BUILD_OS_NAME);
+        g15daemon_log(LOG_DEBUG, "With compiler: %s",COMPILER_VERSION);
+        fprintf(stderr, "G15Daemon CMDLINE ARGS: ");
+        for(i=1;i<argc;i++)
+          fprintf(stderr, "%s ",argv[i]);
+          fprintf(stderr,"\n");
+    }
+    if(uf_return_running()>=0) {
+        g15daemon_log(LOG_ERR,"G15Daemon already running.. Exiting");
+        exit(0);
+    }
+
+    /* set libg15 debugging to our debug setting */
+    if(LIBG15_VERSION>=1200)
+        libg15Debug(g15daemon_debug);
+    
+#ifdef OSTYPE_DARWIN
+     /* OS X: load codeless kext */
+     retval = system("/sbin/kextload " "/System/Library/Extensions/libusbshield.kext");
+		
+     if (WIFEXITED(retval)){
+	if (WEXITSTATUS(retval) !=0){
+		g15daemon_log(LOG_ERR,"Unable to load USB shield kext...exiting");
+		exit(1);
+        }
+     } else {
+	g15daemon_log(LOG_ERR,"Unable to launch kextload...exiting");
+	exit(1);
+     }
+#endif
+
+    /* init stuff here..  */
+    if((retval=initLibG15())!=G15_NO_ERROR){
+        g15daemon_log(LOG_ERR,"Unable to attach to the G15 Keyboard... exiting");
+        exit(1);
+    }
+
+    if(!g15daemon_debug)
+        daemon(0,0);
+
+    if(uf_create_pidfile() == 0) {
+        
+        g15daemon_t *lcdlist;
+        config_section_t *global_cfg=NULL;
+        pthread_attr_t attr;
+        struct passwd *nobody;
+        unsigned char location[1024];
+
+        openlog("g15daemon", LOG_PID, LOG_USER);
+        if(strlen((char*)user)==0){
+            nobody = getpwnam("nobody");
+        }else {
+            nobody = getpwnam((char*)user);
+        }
+        if (nobody==NULL)
+        {
+            nobody = getpwuid(geteuid());
+            g15daemon_log(LOG_WARNING,"BEWARE: running as effective uid %i\n",nobody->pw_uid);
+        }
+        
+        /* initialise the linked list */
+        lcdlist = ll_lcdlist_init();
+        lcdlist->nobody = nobody;
+
+        setLCDContrast(1); 
+        setLEDs(0);
+        lcdlist->kb_backlight_state=1;
+        lcdlist->current->lcd->backlight_state=lcdlevel;
+        setLCDBrightness(lcdlevel);
+
+#ifdef LIBG15_VERSION
+#if LIBG15_VERSION >= 1200
+        setKBBrightness(lcdlist->kb_backlight_state);
+#endif
+#endif                      
+        
+        uf_conf_open(lcdlist, "/etc/g15daemon.conf");
+        global_cfg=g15daemon_cfg_load_section(lcdlist,"Global");
+        if(!cycle_cmdline_override){
+            cycle_key = 1==g15daemon_cfg_read_bool(global_cfg,"Use MR as Cycle Key",0)?G15_KEY_MR:G15_KEY_L1;
+        }
+
+#ifndef OSTYPE_SOLARIS
+               /* all other processes/threads should be seteuid nobody */
+        if(nobody!=NULL) {
+            seteuid(nobody->pw_uid);
+            setegid(nobody->pw_gid);
+        }
+#endif
+        /* initialise the pthread condition for the LCD thread */
+        g15daemon_init_refresh(); 
+        pthread_mutex_init(&g15lib_mutex, NULL);
+        pthread_attr_init(&attr);
+
+        pthread_attr_setstacksize(&attr,512*1024); /* set stack to 512k - dont need 8Mb !! */
+        if (pthread_create(&keyboard_thread, &attr, keyboard_watch_thread, lcdlist) != 0) {
+            g15daemon_log(LOG_ERR,"Unable to create keyboard listener thread.  Exiting");
+            goto exitnow;
+        }
+
+        pthread_attr_setstacksize(&attr,128*1024); 
+
+        if (pthread_create(&lcd_thread, &attr, lcd_draw_thread, lcdlist) != 0) {
+            g15daemon_log(LOG_ERR,"Unable to create display thread.  Exiting");
+            goto exitnow;
+        }
+        g15daemon_log(LOG_INFO,"%s loaded\n",PACKAGE_STRING);
+        
+        snprintf((char*)location,1024,"%s/%s",DATADIR,"g15daemon/splash/g15logo2.wbmp");
+	g15canvas *canvas = (g15canvas *)g15daemon_xmalloc (sizeof (g15canvas));
+	memset (canvas->buffer, 0, G15_BUFFER_LEN);
+	canvas->mode_cache = 0;
+	canvas->mode_reverse = 0;
+	canvas->mode_xor = 0;
+        g15r_loadWbmpSplash(canvas,(char*)location);
+	memcpy (lcdlist->tail->lcd->buf, canvas->buffer, G15_BUFFER_LEN);
+	free (canvas);
+        uf_write_buf_to_g15(lcdlist->tail->lcd);
+	
+        snprintf((char*)location,1024,"%s",PLUGINDIR);
+
+        loaded_plugins = g15_open_all_plugins(lcdlist,(char*)location);
+        
+        new_action.sa_handler = g15daemon_sighandler;
+        new_action.sa_flags = 0;
+        sigaction(SIGINT, &new_action, NULL);
+    	sigaction(SIGQUIT, &new_action, NULL);
+    	sigaction(SIGTERM, &new_action, NULL);
+    	sigaction(SIGUSR1, &new_action, NULL);
+        
+        do {
+            pause();
+        } while( leaving == 0);
+
+        g15daemon_log(LOG_INFO,"Leaving by request");
+
+        pthread_join(lcd_thread,NULL);
+        pthread_join(keyboard_thread,NULL);
+        /* switch off the lcd backlight */
+        char *blank=g15daemon_xmalloc(G15_BUFFER_LEN);
+        writePixmapToLCD((unsigned char*)blank);
+        free(blank);
+        setLCDBrightness(0);
+#ifdef LIBG15_VERSION
+#if LIBG15_VERSION >= 1200
+        /* if SIGUSR1 was sent to kill us, switch off the keyboard backlight as well */
+        if(keyboard_backlight_off_onexit==1)
+          setKBBrightness(0);
+#endif
+#endif
+            
+#ifdef LIBG15_VERSION
+#if LIBG15_VERSION >= 1100
+        exitLibG15(); 
+#endif
+#endif
+        ll_lcdlist_destroy(&lcdlist);
+
+exitnow:
+    /* return to root privilages for the final countdown */
+    seteuid(0);
+    setegid(0);
+    closelog();
+    g15daemon_quit_refresh();
+    uf_conf_write(lcdlist,"/etc/g15daemon.conf");
+    uf_conf_free(lcdlist);
+    unlink("/var/run/g15daemon.pid");
+    }
+    return 0;
+}

=== added directory '.pc/04-open-needs-mode.diff'
=== added directory '.pc/04-open-needs-mode.diff/g15daemon'
=== added file '.pc/04-open-needs-mode.diff/g15daemon/utility_funcs.c'
--- .pc/04-open-needs-mode.diff/g15daemon/utility_funcs.c	1970-01-01 00:00:00 +0000
+++ .pc/04-open-needs-mode.diff/g15daemon/utility_funcs.c	2015-05-21 10:27:39 +0000
@@ -0,0 +1,702 @@
+/*
+    This file is part of g15daemon.
+
+    g15daemon 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.
+
+    g15daemon 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 g15daemon; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    
+    (c) 2006-2008 Mike Lampard, Philip Lawatsch, and others
+
+    $Revision: 449 $ -  $Date: 2008-01-24 17:42:07 +1030 (Thu, 24 Jan 2008) $ $Author: mlampard $
+        
+    This daemon listens on localhost port 15550 for client connections,
+    and arbitrates LCD display.  Allows for multiple simultaneous clients.
+    Client screens can be cycled through by pressing the 'L1' key.
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <ctype.h>
+
+#include <sys/time.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "g15daemon.h"
+#include <libg15.h>
+#include <stdarg.h>
+#include <libg15render.h>
+
+extern unsigned int g15daemon_debug;
+extern volatile int leaving;
+#define G15DAEMON_PIDFILE "/var/run/g15daemon.pid"
+
+pthread_cond_t lcd_refresh = PTHREAD_COND_INITIALIZER;
+
+
+/* if no exitfunc or eventhandler, member should be NULL */
+const plugin_info_t generic_info[] = {
+    /* TYPE, name, initfunc, updatefreq, exitfunc, eventhandler */
+    {G15_PLUGIN_LCD_CLIENT, "BackwardCompatible", NULL, 0, NULL, (void*)internal_generic_eventhandler},
+    {G15_PLUGIN_NONE,        ""          , NULL,     0,   NULL, NULL}
+};
+
+/* handy function from xine_utils.c */
+void *g15daemon_xmalloc(size_t size) {
+    void *ptr;
+
+    /* prevent xmalloc(0) of possibly returning NULL */
+    if( !size )
+        size++;
+
+    if((ptr = calloc(1, size)) == NULL) {
+        g15daemon_log(LOG_WARNING, "g15_xmalloc() failed: %s.\n", strerror(errno));
+        return NULL;
+    }
+    return ptr;
+}
+
+static int refresh_pending=0;
+void g15daemon_init_refresh() {
+  pthread_condattr_t attr;
+  pthread_cond_init(&lcd_refresh, &attr);
+}
+
+void g15daemon_send_refresh(lcd_t *lcd) {
+    if(lcd==lcd->masterlist->current->lcd||lcd->state_changed) {
+      pthread_cond_broadcast(&lcd_refresh);
+      refresh_pending++;
+    }
+}
+
+void g15daemon_wait_refresh() {
+    pthread_mutex_t dummy_mutex;
+    struct timespec timeout;
+    int retval;
+    if(refresh_pending<1) {
+      /* Create a dummy mutex which doesn't unlock for sure while waiting. */
+      pthread_mutex_init(&dummy_mutex, NULL);
+      pthread_mutex_lock(&dummy_mutex);
+start:
+      time(&timeout.tv_sec);
+      timeout.tv_sec += 1;
+      timeout.tv_nsec = 0L;
+
+      retval=pthread_cond_timedwait(&lcd_refresh, &dummy_mutex, &timeout);
+      if(!leaving && retval == ETIMEDOUT)
+        goto start;
+      pthread_mutex_unlock(&dummy_mutex);
+      pthread_mutex_destroy(&dummy_mutex);
+    }
+    refresh_pending--;
+}
+
+void g15daemon_quit_refresh() {
+    pthread_cond_destroy(&lcd_refresh);
+}
+
+int uf_return_running(){
+    int fd;
+    char pidtxt[128];
+    int pid;
+    int l;
+    
+    if ((fd = open(G15DAEMON_PIDFILE, O_RDWR, 0644)) < 0) {
+            return -1;
+    }
+    if((l = read(fd,pidtxt,sizeof(pidtxt)-1)) < 0) {
+        unlink (G15DAEMON_PIDFILE);
+        close(fd);
+        return -1;
+    }
+    if((pid = atoi(pidtxt)) <= 0) {
+        g15daemon_log(LOG_ERR,"pidfile corrupt");
+        unlink(G15DAEMON_PIDFILE);
+        close(fd);
+        return -1;
+    }
+    if((kill(pid,0) != 0) && errno != EPERM ) {
+        g15daemon_log(LOG_ERR,"Process died - removing pidfile");
+        unlink(G15DAEMON_PIDFILE);
+        close(fd);
+        return -1;
+    }
+    
+    return pid;
+    
+}
+
+int uf_create_pidfile() {
+    
+    char pidtxt[128];
+    size_t l;
+    int fd;
+    
+    if(!uf_return_running() &&  (fd = open(G15DAEMON_PIDFILE, O_CREAT|O_RDWR|O_EXCL, 0644)) < 0) {
+        g15daemon_log(LOG_ERR,"previous G15Daemon process died.  removing pidfile");
+        unlink(G15DAEMON_PIDFILE);
+    }
+    if ((fd = open(G15DAEMON_PIDFILE, O_CREAT|O_RDWR|O_EXCL, 0644)) < 0) {
+        return 1;
+    }
+    
+    snprintf(pidtxt, sizeof(pidtxt), "%lu\n", (unsigned long) getpid());
+
+    if (write(fd, pidtxt, l = strlen(pidtxt)) != l) {
+        g15daemon_log(LOG_WARNING, "write(): %s", strerror(errno));
+        unlink(G15DAEMON_PIDFILE);
+    }
+    
+    if(fd>0) {
+        close(fd);
+        return 0;
+    }
+    return 1;
+}
+
+
+/* syslog wrapper */
+int g15daemon_log (int priority, const char *fmt, ...) {
+   va_list argp;
+   va_start (argp, fmt);
+   int real_prio=0;
+   
+   switch(g15daemon_debug) {
+     case 0:
+     case 1:
+      real_prio = LOG_WARNING;
+      break;
+     case 2:
+      real_prio = LOG_INFO;
+      break;
+     default:
+      real_prio = LOG_DEBUG;
+   }
+
+   if(real_prio>=priority) {
+    if(g15daemon_debug == 0) {
+     vsyslog(priority, fmt, argp);
+    } else {
+     vfprintf(stderr,fmt,argp);
+     fprintf(stderr,"\n");
+    }
+   }
+   va_end (argp);
+   
+   return 0;
+}
+
+/* takes a 6880 byte (1byte==1pixel) buffer and packs it into libg15 format. */
+void g15daemon_convert_buf(lcd_t *lcd, unsigned char * orig_buf)
+{
+    unsigned int x,y,val;
+    for(x=0;x<160;x++)
+        for(y=0;y<43;y++)
+	  {
+		unsigned int pixel_offset = y * LCD_WIDTH + x;
+    		unsigned int byte_offset = pixel_offset / 8;
+    		unsigned int bit_offset = 7-(pixel_offset % 8);
+
+		val = orig_buf[x+(y*160)];
+
+    		if (val)
+        		lcd->buf[byte_offset] = lcd->buf[byte_offset] | 1 << bit_offset;
+    		else
+        		lcd->buf[byte_offset] = lcd->buf[byte_offset]  &  ~(1 << bit_offset);
+	  }
+}
+
+/* wrap the libg15 functions */
+int uf_write_buf_to_g15(lcd_t *lcd)
+{
+    int retval = 0;
+#ifdef LIBUSB_BLOCKS
+    retval = writePixmapToLCD(lcd->buf);
+#else
+    pthread_mutex_lock(&g15lib_mutex);
+    retval = writePixmapToLCD(lcd->buf);
+    pthread_mutex_unlock(&g15lib_mutex);
+#endif    
+    return retval;
+}
+
+int uf_read_keypresses(unsigned int *keypresses, unsigned int timeout) 
+{
+    int retval=0;
+#ifdef LIBUSB_BLOCKS
+    retval = getPressedKeys(keypresses, timeout);
+#else
+    pthread_mutex_lock(&g15lib_mutex);
+    retval = getPressedKeys(keypresses, timeout);
+    pthread_mutex_unlock(&g15lib_mutex);
+#endif    
+    return retval;
+}
+
+/* Sleep routine (hackish). */
+void g15daemon_sleep(int seconds) {
+    pthread_mutex_t dummy_mutex;
+    static pthread_cond_t dummy_cond = PTHREAD_COND_INITIALIZER;
+    struct timespec timeout;
+
+    /* Create a dummy mutex which doesn't unlock for sure while waiting. */
+    pthread_mutex_init(&dummy_mutex, NULL);
+    pthread_mutex_lock(&dummy_mutex);
+
+    timeout.tv_sec = time(NULL) + seconds;
+    timeout.tv_nsec = 0;
+
+    pthread_cond_timedwait(&dummy_cond, &dummy_mutex, &timeout);
+
+    /*    pthread_cond_destroy(&dummy_cond); */
+    pthread_mutex_unlock(&dummy_mutex);
+    pthread_mutex_destroy(&dummy_mutex);
+}
+
+/* microsecond sleep routine. */
+int g15daemon_usleep(int useconds) {
+    
+    struct timeval timeout;
+    if(useconds < 10000)
+      useconds = 10000;
+    timeout.tv_sec = useconds / 1000000;
+    timeout.tv_usec = useconds % 1000000;
+    return select (0,0,0,0,&timeout);
+}
+
+/* millisecond sleep routine. */
+int g15daemon_msleep(int milliseconds) {
+    
+    return g15daemon_usleep(milliseconds*1000);
+}
+
+
+unsigned int g15daemon_gettime_ms(){
+    struct timeval tv;
+    gettimeofday(&tv,NULL);
+    return (tv.tv_sec*1000+tv.tv_usec/1000);
+}
+
+/* generic event handler used unless overridden (only loading a plugin will override currently)*/
+int internal_generic_eventhandler(plugin_event_t *event) {
+    
+    lcd_t *lcd = (lcd_t*) event->lcd;
+    
+    switch (event->event)
+    {
+        case G15_EVENT_KEYPRESS: {
+            if(lcd->g15plugin->plugin_handle){ /* loadable plugin */
+                 /* plugin had null for eventhandler therefore doesnt want events.. throw them away */
+            }
+        }
+        break;
+        case G15_EVENT_VISIBILITY_CHANGED:
+          break;
+        default:
+          break;
+    }
+    return G15_PLUGIN_OK;
+}
+
+
+/* free all memory used by the config subsystem */
+void uf_conf_free(g15daemon_t *list)
+{
+    config_section_t *section=list->config->sections;
+    config_items_t *tmpitem=NULL;
+    config_section_t *tmpsection=section;
+    
+    while(tmpsection!=NULL){
+        tmpitem=section->items;
+        
+        if(section->sectionname){
+            free(section->sectionname);
+            while(section->items!=NULL){
+                if(tmpitem->key!=NULL) 
+                    free(tmpitem->key);
+                if(tmpitem->value!=NULL)
+                    free(tmpitem->value);
+                tmpitem=section->items->next;
+                free(section->items);
+                section->items=tmpitem;
+            }
+        }
+        tmpsection=section->next;
+        free(section);
+        section=tmpsection;
+    }
+    free(section);
+    free(list->config);
+}
+
+/* write the config file with all keys/sections */
+int uf_conf_write(g15daemon_t *list,char *filename)
+{
+    int config_fd=-1;
+    config_section_t *foo=list->config->sections;
+    config_items_t * item=NULL;
+    char line[1024];
+    
+    config_fd = open(filename,O_CREAT|O_RDWR|O_TRUNC);
+    if(config_fd){
+    snprintf(line,1024,"# G15Daemon Configuration File\n# any items entered before a [section] header\n# will be in the Global config space\n# comments you wish to keep should start with a semicolon';'\n");
+    write(config_fd,line,strlen(line));
+    while(foo!=NULL){
+        item=foo->items;
+        memset(line,0,1024);
+        if(foo->sectionname!=NULL){
+            snprintf(line,1024,"\n[%s]\n",foo->sectionname);
+            write(config_fd,line,strlen(line));
+            while(item!=NULL){
+                memset(line,0,1024);
+                if(item->key!=NULL){
+                    if(item->key[0]==';') // comment
+                        snprintf(line,1024,"%s\n",item->key);
+                    else
+                        snprintf(line,1024,"%s: %s\n",item->key, item->value);
+                    write(config_fd,line,strlen(line));
+                }
+                item=item->next;
+            }
+        }
+        foo=foo->next;
+    }
+    close(config_fd);
+    return 0;
+    }
+    return -1;
+}
+
+/* search the list for valid section name return pointer to section, or NULL otherwise */
+config_section_t* uf_search_confsection(g15daemon_t *list,char *sectionname){
+    config_section_t *section=list->config->sections;
+    
+    while(section!=NULL){
+        if(0==strcmp((char*)section->sectionname,(char*)sectionname))
+            break;
+        section=section->next;
+    }
+    return section;
+}
+
+/* search the list for valid key called "key" in section named "section" return pointer to item or NULL */
+config_items_t* uf_search_confitem(config_section_t *section, char *key){
+    
+    config_items_t * item=NULL;
+    
+    if(section!=NULL){
+        item=section->items;
+        while(item!=NULL){
+            if(0==strcmp((char*)item->key,(char*)key))
+                break;
+            item=item->next;
+        }
+    }
+    return item;
+}
+
+
+/* return pointer to section, or create a new section if it doesnt exist */
+config_section_t *g15daemon_cfg_load_section(g15daemon_t *masterlist,char *name) {
+    
+    config_section_t *new = NULL;
+    if((new=uf_search_confsection(masterlist,name))!=NULL)
+        return new;
+    new = g15daemon_xmalloc(sizeof(config_section_t));
+    new->head = new;
+    new->next = NULL;;
+    new->sectionname=strdup(name);
+    if(!masterlist->config->sections){
+        masterlist->config->sections=new;
+        masterlist->config->sections->head = new;
+    } else {
+        masterlist->config->sections->head->next=new;
+        masterlist->config->sections->head = new;
+    }
+    return new;
+}
+
+/* cleanup whitespace */
+char * uf_remove_whitespace(char *str){
+    int z=0;
+    if(str==NULL)
+        str=strdup(" ");
+    while(isspace(str[z])&&str[z])
+        z++;
+    str+=z;
+    return str;
+}
+
+/* add a new key, or update the value of an already existing key, or return -1 if section doesnt exist */
+int g15daemon_cfg_write_string(config_section_t *section, char *key, char *val){
+    
+    config_items_t *new = NULL;
+
+    if(section==NULL)
+        return -1;
+    
+    if((uf_search_confitem(section, key))){
+        free(new);
+        new=uf_search_confitem(section, key);
+        new->value=strdup(val);
+    }else{
+        new=g15daemon_xmalloc(sizeof(config_items_t));
+        new->head=new;
+        new->next=NULL;
+        
+        new->key=strdup(key);
+        new->value=strdup(val);
+        if(!section->items){
+            new->prev=NULL;
+            section->items=new;
+            section->items->head=new;
+        }else{
+            new->prev=section->items->head;
+            section->items->head->next=new;
+            section->items->head=new;
+        }
+    }
+    return 0;
+}
+
+/* remoe a key/value pair from named section */
+int g15daemon_cfg_remove_key(config_section_t *section, char *key){
+    
+    config_items_t *new = NULL;
+    config_items_t *next = NULL;
+    config_items_t *prev = NULL;
+    if(section==NULL)
+        return -1;
+    
+    if((uf_search_confitem(section, key))){
+        new=uf_search_confitem(section, key);
+        prev=new->prev;
+        next=new->next;
+        if(prev){
+            prev->next=new->next;
+        }else{
+             if(!next) {
+                    free(section->items);
+                    section->items=NULL;
+                }
+                else
+                    section->items=next;
+            }
+
+        if(new->head==new){
+            if(prev){
+                prev->head = prev;
+                section->items->head=prev;
+            }
+            if(!prev){
+                if(!next) {
+                    free(section->items);
+                    section->items=NULL;
+                }
+            }
+        }
+        if(next){
+            if(prev)
+            	next->prev=prev;
+            else
+                next->prev=NULL;
+        }
+        free(new->key);
+        free(new->value);
+        free(new);
+    }
+    return 0;
+}
+
+int g15daemon_cfg_write_int(config_section_t *section, char *key, int val) {
+    char tmp[1024];
+    snprintf(tmp,1024,"%i",val);
+    return g15daemon_cfg_write_string(section, key, tmp);
+}
+
+int g15daemon_cfg_write_float(config_section_t *section, char *key, double val) {
+    char tmp[1024];
+    snprintf(tmp,1024,"%f",val);
+    return g15daemon_cfg_write_string(section, key, tmp);
+}
+
+/* simply write value as On or Off depending on whether val>0 */
+int g15daemon_cfg_write_bool(config_section_t *section, char *key, unsigned int val) {
+    char tmp[1024];
+    snprintf(tmp,1024,"%s",val?"On":"Off");
+    return g15daemon_cfg_write_string(section, key, tmp);
+}
+
+/* the config read functions will either return a value from the config file, or the default value, which will be written to the config file if the key doesnt exist */
+
+/* return bool as int from key in sectionname */
+int g15daemon_cfg_read_bool(config_section_t *section, char *key, int defaultval) {
+    
+    int retval=0;
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+        retval = 1^retval?(strncmp(item->value,"On",2)==0):1;
+           return retval;
+    }
+    g15daemon_cfg_write_bool(section, key, defaultval);
+    return defaultval;
+}
+
+/* return int from key in sectionname */
+int g15daemon_cfg_read_int(config_section_t *section, char *key, int defaultval) {
+    
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+           return atoi(item->value);
+    }
+    g15daemon_cfg_write_int(section, key, defaultval);
+    return defaultval;
+}
+
+/* return float from key in sectionname */
+double g15daemon_cfg_read_float(config_section_t *section, char *key, double defaultval) {
+    
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+           return atof(item->value);
+    }
+    g15daemon_cfg_write_float(section, key, defaultval);
+    return defaultval;
+}
+
+/* return string value from key in sectionname */
+char* g15daemon_cfg_read_string(config_section_t *section, char *key, char *defaultval) {
+    
+    config_items_t *item = uf_search_confitem(section, key);
+    if(item){
+           return item->value;
+    }
+    g15daemon_cfg_write_string(section, key, defaultval);
+    return defaultval;
+}
+
+
+int uf_conf_open(g15daemon_t *list, char *filename) {
+
+    char *buffer, *lines;
+    int config_fd=-1;
+    char *sect;
+    char *start;
+    char *bar = NULL;
+    int i;
+    struct stat stats;
+	
+    list->config=g15daemon_xmalloc(sizeof(configfile_t));
+    list->config->sections=NULL;
+
+    if (lstat(filename, &stats) == -1)
+        return -1;
+    if (!(config_fd = open(filename, O_RDWR)))
+        return -1;
+
+    buffer = g15daemon_xmalloc(stats.st_size + 1);
+        
+    if (read(config_fd, buffer, stats.st_size) != stats.st_size)
+    {
+        free(buffer);
+        close(config_fd);
+        return -1;
+    }
+    close(config_fd);
+    buffer[stats.st_size] = '\0';
+        
+    lines=strtok_r(buffer,"\n",&bar);
+    config_section_t *section=NULL;
+    while(lines!=NULL){
+        sect=strdup(lines);
+        
+        i=0;
+        while(isspace(sect[i])){
+            i++;
+        }
+        start=sect+i;
+        if(start[0]=='#'){
+	   /* header - ignore */
+           /* comments start with ; and can be produced like so:
+             g15daemon_cfg_write_string(noload_cfg,"; Plugins in this section will not be loaded on start","");
+             the value parameter must not be used.
+           */
+        } else if(strrchr(start,']')) { /* section title */
+            char sectiontitle[1024];
+            memset(sectiontitle,0,1024);
+            strncpy(sectiontitle,start+1,strlen(start)-2);
+            section = g15daemon_cfg_load_section(list,sectiontitle);
+        }else{
+            /*section keys */
+            if(section==NULL){
+                /* create an internal section "Global" which is the default for items not under a [section] header */
+                section=g15daemon_cfg_load_section(list,"Global");
+            }
+            char *foo=NULL;
+            char *key = uf_remove_whitespace( strtok_r(start,":=",&foo) );
+            char *val = uf_remove_whitespace( strtok_r(NULL,":=", &foo) );
+            
+            g15daemon_cfg_write_string(section,key,val);
+        }        
+        free(sect);
+        lines=strtok_r(NULL,"\n",&bar);
+    }
+
+    free(buffer);
+    return 0;
+}
+
+int uf_screendump_pbm(unsigned char *buffer,char *filename) {
+    int fd;
+    FILE *f;
+    int x,y;
+    #define WIDTH 40
+    g15canvas *canvas=g15daemon_xmalloc(sizeof(g15canvas));
+    memcpy(canvas->buffer,buffer,LCD_BUFSIZE);
+    fd = open(filename, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+    if(fd == -1) {
+       g15daemon_log(LOG_WARNING, "uf_screendump_pbm failed: open, %s.\n", strerror(errno));
+       return -1;
+    }
+    f = fdopen(fd,"w");
+    if(f==NULL) {
+       close(fd);
+        g15daemon_log(LOG_WARNING, "uf_screendump_pbm failed: fdopen, %s.\n", strerror(errno));
+        return -1;
+    }
+
+    fprintf(f,"P1\n160 43\n");
+    fprintf(f,"# G15 screendump - %s\n\n",filename);
+    for(y=0;y<43;y++)
+      for(x=0;x<160;x++) {
+        fprintf(f,"%i",g15r_getPixel(canvas,x,y));
+            if(x%WIDTH==WIDTH-1)
+              fprintf(f,"\n");
+        }
+
+    fclose(f);
+    fsync(fd);
+    close(fd);
+    free(canvas);
+    return 0;
+}
+

=== added directory '.pc/05-send-a-sync-event-after-key-up-down.diff'
=== added directory '.pc/05-send-a-sync-event-after-key-up-down.diff/plugins'
=== added file '.pc/05-send-a-sync-event-after-key-up-down.diff/plugins/g15_plugin_uinput.c'
--- .pc/05-send-a-sync-event-after-key-up-down.diff/plugins/g15_plugin_uinput.c	1970-01-01 00:00:00 +0000
+++ .pc/05-send-a-sync-event-after-key-up-down.diff/plugins/g15_plugin_uinput.c	2015-05-21 10:27:39 +0000
@@ -0,0 +1,324 @@
+/*
+    This file is part of g15daemon.
+
+    g15daemon 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.
+
+    g15daemon 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 g15daemon; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    (c) 2006-2008 Mike Lampard, Philip Lawatsch, and others
+    
+    $Revision: 388 $ -  $Date: 2008-01-02 12:57:03 +1030 (Wed, 02 Jan 2008) $ $Author: mlampard $
+    
+    UINPUT key processing plugin.  receives events and sends keycodes to the linux kernel.
+*/
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <config.h>
+#include <g15daemon.h>
+#include <pwd.h>
+
+#ifdef HAVE_CONFIG_H
+#ifdef HAVE_LINUX_UINPUT_H
+#include <linux/input.h>
+#include <linux/uinput.h>
+
+#include <libg15.h>
+
+static int uinp_fd = -1;
+static config_section_t *uinput_cfg=NULL;
+static int map_Lkeys = 0;
+
+#define GKEY_OFFSET 167
+#define MKEY_OFFSET 185
+#define LKEY_OFFSET 189
+
+#define G15KEY_DOWN 1
+#define G15KEY_UP 0
+
+static int g15_init_uinput(void *plugin_args) {
+    
+    int i=0;
+    char *custom_filename;
+    g15daemon_t *masterlist = (g15daemon_t*) plugin_args;
+    struct uinput_user_dev uinp;
+    static const char *uinput_device_fn[] = { "/dev/uinput", "/dev/input/uinput","/dev/misc/uinput",0};
+    
+    uinput_cfg = g15daemon_cfg_load_section(masterlist,"Keyboard OS Mapping (uinput)");
+    custom_filename = g15daemon_cfg_read_string(uinput_cfg, "device",(char*)uinput_device_fn[1]);
+    map_Lkeys=g15daemon_cfg_read_int(uinput_cfg, "Lkeys.mapped",0);
+    
+    seteuid(0);
+    setegid(0);
+    while (uinput_device_fn[i] && (uinp_fd = open(uinput_device_fn[i],O_RDWR))<0){
+        ++i;
+    }
+    if(uinp_fd<0) {	/* try reading the users preference in the config */
+        uinp_fd = open(custom_filename,O_RDWR);
+    }
+    if(uinp_fd<0){
+        g15daemon_log(LOG_ERR,"Unable to open UINPUT device.  Please ensure the uinput driver is loaded into the kernel and that you have permission to open the device.");
+        return -1;
+    }
+    /* all other processes/threads should be seteuid nobody */
+     seteuid(masterlist->nobody->pw_uid);
+     setegid(masterlist->nobody->pw_gid);
+    
+    
+    memset(&uinp,0,sizeof(uinp));
+    strncpy(uinp.name, "G15 Extra Keys", UINPUT_MAX_NAME_SIZE);
+
+#ifdef HAVE_UINPUT_USER_DEV_ID
+    uinp.id.version = 4;
+    uinp.id.bustype = BUS_USB;
+#else
+    uinp.idversion = 4;
+    uinp.idbus = BUS_USB;
+#endif 
+
+    ioctl(uinp_fd, UI_SET_EVBIT, EV_KEY);
+
+    for (i=0; i<256; ++i)
+        ioctl(uinp_fd, UI_SET_KEYBIT, i);
+
+    write(uinp_fd, &uinp, sizeof(uinp));
+    
+    if (ioctl(uinp_fd, UI_DEV_CREATE))
+    {
+        g15daemon_log(LOG_ERR,"Unable to create UINPUT device.");
+        return -1;
+    }
+    return 0;
+}
+
+void g15_exit_uinput(void *plugin_args){
+    ioctl(uinp_fd, UI_DEV_DESTROY);
+    close(uinp_fd);
+}
+
+
+static void g15_uinput_keydown(unsigned char code)
+{
+    struct input_event event;
+    memset(&event, 0, sizeof(event));
+
+    event.type = EV_KEY;
+    event.code = code;
+    event.value = G15KEY_DOWN;
+    
+    write (uinp_fd, &event, sizeof(event));
+}
+
+static void g15_uinput_keyup(unsigned char code)
+{
+    struct input_event event;
+    memset(&event, 0, sizeof(event));
+
+    event.type = EV_KEY;
+    event.code = code;
+    event.value = G15KEY_UP;
+    
+    write (uinp_fd, &event, sizeof(event));
+}
+
+    void (*keyup)(unsigned char code) = &g15_uinput_keyup;
+    void (*keydown)(unsigned char code) = &g15_uinput_keydown;
+#else
+    void keyup(unsigned char code) { printf("Extra Keys not supported due to missing Uinput.h\n"); }
+    void keydown(unsigned char code) { printf("Extra Keys not supported due to missing Uinput.h\n"); }
+#endif
+#endif
+    
+static void g15_process_keys(g15daemon_t *masterlist, unsigned int currentkeys, unsigned int lastkeys)
+{
+    /* 'G' keys */
+    if((currentkeys & G15_KEY_G1) && !(lastkeys & G15_KEY_G1))
+        keydown(GKEY_OFFSET);
+    else if(!(currentkeys & G15_KEY_G1) && (lastkeys & G15_KEY_G1))
+        keyup(GKEY_OFFSET);
+
+    if((currentkeys & G15_KEY_G2) && !(lastkeys & G15_KEY_G2))
+        keydown(GKEY_OFFSET+1);
+    else if(!(currentkeys & G15_KEY_G2) && (lastkeys & G15_KEY_G2))
+        keyup(GKEY_OFFSET+1);
+
+    if((currentkeys & G15_KEY_G3) && !(lastkeys & G15_KEY_G3))
+        keydown(GKEY_OFFSET+2);
+    else if(!(currentkeys & G15_KEY_G3) && (lastkeys & G15_KEY_G3))
+        keyup(GKEY_OFFSET+2);
+
+    if((currentkeys & G15_KEY_G4) && !(lastkeys & G15_KEY_G4))
+        keydown(GKEY_OFFSET+3);
+    else if(!(currentkeys & G15_KEY_G4) && (lastkeys & G15_KEY_G4))
+        keyup(GKEY_OFFSET+3);
+
+    if((currentkeys & G15_KEY_G5) && !(lastkeys & G15_KEY_G5))
+        keydown(GKEY_OFFSET+4);
+    else if(!(currentkeys & G15_KEY_G5) && (lastkeys & G15_KEY_G5))
+        keyup(GKEY_OFFSET+4);
+
+    if((currentkeys & G15_KEY_G6) && !(lastkeys & G15_KEY_G6))
+        keydown(GKEY_OFFSET+5);
+    else if(!(currentkeys & G15_KEY_G6) && (lastkeys & G15_KEY_G6))
+        keyup(GKEY_OFFSET+5);
+
+    if((currentkeys & G15_KEY_G7) && !(lastkeys & G15_KEY_G7))
+        keydown(GKEY_OFFSET+6);
+    else if(!(currentkeys & G15_KEY_G7) && (lastkeys & G15_KEY_G7))
+        keyup(GKEY_OFFSET+6);
+
+    if((currentkeys & G15_KEY_G8) && !(lastkeys & G15_KEY_G8))
+        keydown(GKEY_OFFSET+7);
+    else if(!(currentkeys & G15_KEY_G8) && (lastkeys & G15_KEY_G8))
+        keyup(GKEY_OFFSET+7);
+
+    if((currentkeys & G15_KEY_G9) && !(lastkeys & G15_KEY_G9))
+        keydown(GKEY_OFFSET+8);
+    else if(!(currentkeys & G15_KEY_G9) && (lastkeys & G15_KEY_G9))
+        keyup(GKEY_OFFSET+8);
+
+    if((currentkeys & G15_KEY_G10) && !(lastkeys & G15_KEY_G10))
+        keydown(GKEY_OFFSET+9);
+    else if(!(currentkeys & G15_KEY_G10) && (lastkeys & G15_KEY_G10))
+        keyup(GKEY_OFFSET+9);
+
+    if((currentkeys & G15_KEY_G11) && !(lastkeys & G15_KEY_G11))
+        keydown(GKEY_OFFSET+10);
+    else if(!(currentkeys & G15_KEY_G11) && (lastkeys & G15_KEY_G11))
+        keyup(GKEY_OFFSET+10);
+
+    if((currentkeys & G15_KEY_G12) && !(lastkeys & G15_KEY_G12))
+        keydown(GKEY_OFFSET+11);
+    else if(!(currentkeys & G15_KEY_G12) && (lastkeys & G15_KEY_G12))
+        keyup(GKEY_OFFSET+11);
+
+    if((currentkeys & G15_KEY_G13) && !(lastkeys & G15_KEY_G13))
+        keydown(GKEY_OFFSET+12);
+    else if(!(currentkeys & G15_KEY_G13) && (lastkeys & G15_KEY_G13))
+        keyup(GKEY_OFFSET+12);
+
+    if((currentkeys & G15_KEY_G14) && !(lastkeys & G15_KEY_G14))
+        keydown(GKEY_OFFSET+13);
+    else if(!(currentkeys & G15_KEY_G14) && (lastkeys & G15_KEY_G14))
+        keyup(GKEY_OFFSET+13);
+
+    if((currentkeys & G15_KEY_G15) && !(lastkeys & G15_KEY_G15))
+        keydown(GKEY_OFFSET+14);
+    else if(!(currentkeys & G15_KEY_G15) && (lastkeys & G15_KEY_G15))
+        keyup(GKEY_OFFSET+14);
+
+    if((currentkeys & G15_KEY_G16) && !(lastkeys & G15_KEY_G16))
+        keydown(GKEY_OFFSET+15);
+    else if(!(currentkeys & G15_KEY_G16) && (lastkeys & G15_KEY_G16))
+        keyup(GKEY_OFFSET+15);
+
+    if((currentkeys & G15_KEY_G17) && !(lastkeys & G15_KEY_G17))
+        keydown(GKEY_OFFSET+16);
+    else if(!(currentkeys & G15_KEY_G17) && (lastkeys & G15_KEY_G17))
+        keyup(GKEY_OFFSET+16);
+
+    if((currentkeys & G15_KEY_G18) && !(lastkeys & G15_KEY_G18))
+        keydown(GKEY_OFFSET+17);
+    else if(!(currentkeys & G15_KEY_G18) && (lastkeys & G15_KEY_G18))
+        keyup(GKEY_OFFSET+17);
+
+    /* 'M' keys */
+
+    if((currentkeys & G15_KEY_M1) && !(lastkeys & G15_KEY_M1))
+        keydown(MKEY_OFFSET);
+    else if(!(currentkeys & G15_KEY_M1) && (lastkeys & G15_KEY_M1))
+        keyup(MKEY_OFFSET);
+
+    if((currentkeys & G15_KEY_M2) && !(lastkeys & G15_KEY_M2))
+        keydown(MKEY_OFFSET+1);
+    else if(!(currentkeys & G15_KEY_M2) && (lastkeys & G15_KEY_M2))
+        keyup(MKEY_OFFSET+1);
+
+    if((currentkeys & G15_KEY_M3) && !(lastkeys & G15_KEY_M3))
+        keydown(MKEY_OFFSET+2);
+    else if(!(currentkeys & G15_KEY_M3) && (lastkeys & G15_KEY_M3))
+        keyup(MKEY_OFFSET+2);
+
+    if((currentkeys & G15_KEY_MR) && !(lastkeys & G15_KEY_MR))
+        keydown(MKEY_OFFSET+3);
+    else if(!(currentkeys & G15_KEY_MR) && (lastkeys & G15_KEY_MR))
+        keyup(MKEY_OFFSET+3);
+    
+    if(map_Lkeys){
+        /* 'L' keys...  */
+        if((currentkeys & G15_KEY_L1) && !(lastkeys & G15_KEY_L1))
+            keydown(LKEY_OFFSET);
+        else if(!(currentkeys & G15_KEY_L1) && (lastkeys & G15_KEY_L1))
+            keyup(LKEY_OFFSET);
+
+        if((currentkeys & G15_KEY_L2) && !(lastkeys & G15_KEY_L2))
+            keydown(LKEY_OFFSET+1);
+        else if(!(currentkeys & G15_KEY_L2) && (lastkeys & G15_KEY_L2))
+            keyup(LKEY_OFFSET+1);
+
+        if((currentkeys & G15_KEY_L3) && !(lastkeys & G15_KEY_L3))
+            keydown(LKEY_OFFSET+2);
+        else if(!(currentkeys & G15_KEY_L3) && (lastkeys & G15_KEY_L3))
+            keyup(LKEY_OFFSET+2);
+
+        if((currentkeys & G15_KEY_L4) && !(lastkeys & G15_KEY_L4))
+            keydown(LKEY_OFFSET+3);
+        else if(!(currentkeys & G15_KEY_L4) && (lastkeys & G15_KEY_L4))
+            keyup(LKEY_OFFSET+3);
+
+        if((currentkeys & G15_KEY_L5) && !(lastkeys & G15_KEY_L5))
+            keydown(LKEY_OFFSET+4);
+        else if(!(currentkeys & G15_KEY_L5) && (lastkeys & G15_KEY_L5))
+            keyup(LKEY_OFFSET+4);
+    }
+}
+
+
+static int keyevents(plugin_event_t *myevent) {
+    lcd_t *lcd = (lcd_t*) myevent->lcd;
+    static int lastkeys;
+    switch (myevent->event)
+    {
+        case G15_EVENT_KEYPRESS:{
+            g15_process_keys(lcd->masterlist, myevent->value,lastkeys);
+            lastkeys = myevent->value;
+            break;
+        }
+        case G15_EVENT_VISIBILITY_CHANGED:
+        case G15_EVENT_USER_FOREGROUND:
+	case G15_EVENT_MLED:
+        case G15_EVENT_BACKLIGHT:
+        case G15_EVENT_CONTRAST:
+        case G15_EVENT_REQ_PRIORITY:
+        case G15_EVENT_CYCLE_PRIORITY:
+        default:
+            break;
+    }
+    return G15_PLUGIN_OK;
+}
+
+
+    /* if no exitfunc or eventhandler, member should be NULL */
+plugin_info_t g15plugin_info[] = {
+        /* TYPE, name, initfunc, updatefreq, exitfunc, eventhandler, initfunc */
+   {G15_PLUGIN_CORE_OS_KB, "Linux UINPUT Keyboard Output"	, NULL, 500, (void*)g15_exit_uinput, (void*)keyevents, (void*)g15_init_uinput},
+   {G15_PLUGIN_NONE,               ""          			, NULL,   0,   			NULL,            NULL,           NULL}
+};

=== added directory '.pc/06-fix-buffer-overflow.diff'
=== added directory '.pc/06-fix-buffer-overflow.diff/libg15daemon_client'
=== added file '.pc/06-fix-buffer-overflow.diff/libg15daemon_client/g15daemon_net.c'
--- .pc/06-fix-buffer-overflow.diff/libg15daemon_client/g15daemon_net.c	1970-01-01 00:00:00 +0000
+++ .pc/06-fix-buffer-overflow.diff/libg15daemon_client/g15daemon_net.c	2015-05-21 10:27:39 +0000
@@ -0,0 +1,297 @@
+/*
+    This file is part of g15daemon.
+
+    g15daemon 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.
+
+    g15daemon 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 g15daemon; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    
+    (c) 2006-2008 Mike Lampard, Philip Lawatsch, and others
+    
+    $Revision: 451 $ -  $Date: 2008-01-25 15:15:04 +1030 (Fri, 25 Jan 2008) $ $Author: mlampard $
+    
+    This daemon listens on localhost port 15550 for client connections,
+    and arbitrates LCD display.  Allows for multiple simultaneous clients.
+    Client screens can be cycled through by pressing the 'L1' key.
+*/
+
+#include <string.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <poll.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include <config.h>
+
+#include <libg15.h>
+#include "g15daemon_client.h" 
+
+#ifndef SO_PRIORITY
+#define SO_PRIORITY 12
+#endif
+
+#define G15SERVER_PORT 15550
+#define G15SERVER_ADDR "127.0.0.1"
+int leaving = 0;
+
+const char *g15daemon_version () {
+  return VERSION;
+}
+
+#ifdef HAVE_BACKTRACE
+
+#include <signal.h>
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+#define BACKTRACE_LEN 100
+_Bool segv_init = 0;
+
+/* sighandler function to print backtrace on segfault */
+
+void g15_sighandler(int sig) {
+  int i,nptrs;
+  void *buf[BACKTRACE_LEN];
+  char **btfuncs;
+
+  switch (sig) {
+    case SIGSEGV:
+    #ifdef HAVE_EXECINFO_H
+        fprintf(stderr, "The application (or it's libraries) caught a Segmentation Fault. Backtrace follows:\n");
+        nptrs = backtrace(buf,BACKTRACE_LEN);
+    
+        btfuncs = backtrace_symbols(buf,nptrs);
+        if(btfuncs == NULL)
+          return;
+      
+        for(i=0;i<nptrs;i++)
+          fprintf(stderr,"Backtrace: %s\n",btfuncs[i]);
+        fprintf(stderr,"End of Backtrace.\n");      
+        free(btfuncs);
+        exit(1);
+    #endif
+    break;
+  }
+}
+#endif
+
+int new_g15_screen(int screentype)
+{
+    struct sigaction new_sigaction;
+    int g15screen_fd;
+    struct sockaddr_in serv_addr;
+    static int sighandler_init=0;
+    /* raise the priority of our packets */
+    int tos = 0x6;
+
+    char buffer[256];
+    if(sighandler_init==0) {
+#ifdef HAVE_BACKTRACE
+      new_sigaction.sa_handler = g15_sighandler;
+      new_sigaction.sa_flags = 0;
+      sigaction(SIGSEGV,&new_sigaction,NULL);
+#endif      
+      sighandler_init=1;
+    }
+    
+    g15screen_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (g15screen_fd < 0) 
+        return -1;
+    
+    memset(&serv_addr, 0, sizeof(serv_addr));
+    serv_addr.sin_family      = AF_INET;
+    inet_aton (G15SERVER_ADDR, &serv_addr.sin_addr);
+    serv_addr.sin_port        = htons(G15SERVER_PORT);
+
+    if (connect(g15screen_fd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) 
+        return -1;
+    
+    setsockopt(g15screen_fd, SOL_SOCKET, SO_PRIORITY, &tos, sizeof(tos));
+
+    if (fcntl(g15screen_fd, F_SETFL, O_NONBLOCK) <0 ) {
+    }
+                        
+    memset(buffer,0,256);
+    if(g15_recv(g15screen_fd, buffer, 16)<0)
+        return -1;
+    
+    /* here we check that we're really talking to the g15daemon */
+    if(strcmp(buffer,"G15 daemon HELLO") != 0)
+        return -1;
+    if(screentype == G15_TEXTBUF) /* txt buffer - not supported yet */
+        g15_send(g15screen_fd,"TBUF",4);
+    else if(screentype == G15_WBMPBUF) /* wbmp buffer */
+        g15_send(g15screen_fd,"WBUF",4);
+    else if(screentype == G15_G15RBUF)
+        g15_send(g15screen_fd,"RBUF",4);
+    else 
+        g15_send(g15screen_fd,"GBUF",4);
+    
+    return g15screen_fd;
+}
+
+int g15_close_screen(int sock) 
+{
+    return close(sock);
+}
+
+int g15_send(int sock, char *buf, unsigned int len)
+{
+    int total = 0;
+    int retval = 0;
+    int bytesleft = len;
+    struct pollfd pfd[1];
+    
+    while(total < len && !leaving) {
+        memset(pfd,0,sizeof(pfd));
+        pfd[0].fd = sock;
+        pfd[0].events = POLLOUT|POLLERR|POLLHUP|POLLNVAL;
+        if(poll(pfd,1,500)>=0) {
+            if(pfd[0].revents & POLLOUT && !(pfd[0].revents & POLLERR || pfd[0].revents & POLLHUP || pfd[0].revents & POLLNVAL) ) {
+                retval = send(sock, buf+total, bytesleft, MSG_DONTWAIT);
+                if (retval == -1) { 
+                    break; 
+                }
+                bytesleft -= retval;
+                total += retval;
+            }
+            if((pfd[0].revents & POLLERR|| pfd[0].revents & POLLHUP || pfd[0].revents & POLLNVAL)){
+              retval=-1;
+              break;
+            }
+        }
+    }
+    return retval==-1?-1:0;
+} 
+
+int g15_recv(int sock, char *buf, unsigned int len)
+{
+    int total = 0;
+    int retval = 0;
+    int bytesleft = len; 
+    struct pollfd pfd[1];
+    
+    while(total < len  && !leaving) {
+        memset(pfd,0,sizeof(pfd));
+        pfd[0].fd = sock;
+        pfd[0].events = POLLIN;
+        if(poll(pfd,1,500)>0){
+            if(pfd[0].revents & POLLIN) {
+                retval = recv(sock, buf+total, bytesleft, 0);
+                if (retval < 1) { 
+                    break; 
+                }
+                total += retval;
+                bytesleft -= retval;
+            }
+        }
+    }
+    return total;
+} 
+
+/* receive a byte from a priority, out-of-band packet */
+int g15_recv_oob_answer(int sock) {
+    int packet[2];
+    int msgret = 0;
+    struct pollfd pfd[1];
+    memset(pfd,0,sizeof(pfd));
+    memset(packet,0,2);
+    pfd[0].fd = sock;
+    pfd[0].events = POLLPRI | POLLERR | POLLHUP | POLLNVAL;
+
+    if(poll(pfd,1,100)>0){
+       if(pfd[0].revents & POLLPRI && !(pfd[0].revents & POLLERR || pfd[0].revents & POLLHUP || pfd[0].revents & POLLNVAL)) { 
+             memset(packet,0,sizeof(packet));
+             msgret = recv(sock, packet, 10 , MSG_OOB);
+             if (msgret < 1) {
+                  return -1;
+              }
+       }
+    }
+    return packet[0];
+}
+
+unsigned long g15_send_cmd (int sock, unsigned char command, unsigned char value)
+{
+    int retval;
+    unsigned char packet[2];
+    
+    switch (command) {
+        case G15DAEMON_KEY_HANDLER:
+            if (value > G15_LED_MR)
+                value = G15_LED_MR;
+            packet[0] = (unsigned char)command | (unsigned char)value;            
+            retval = send( sock, packet, 1, MSG_OOB );
+            break;
+        case G15DAEMON_CONTRAST:
+            if (value > G15_CONTRAST_HIGH)
+                value = G15_CONTRAST_HIGH;
+            packet[0] = (unsigned char)command | (unsigned char)value;       
+            send( sock, packet, 1, MSG_OOB );
+            retval = g15_recv_oob_answer(sock);
+            break;
+        case G15DAEMON_BACKLIGHT:
+            if (value > G15_BRIGHTNESS_BRIGHT)
+                value = G15_BRIGHTNESS_BRIGHT;
+            packet[0] = (unsigned char)command | (unsigned char)value;
+            send( sock, packet, 1, MSG_OOB );
+            retval = g15_recv_oob_answer(sock);
+            break;
+        case G15DAEMON_KB_BACKLIGHT:
+            if (value > G15_BRIGHTNESS_BRIGHT)
+                value = G15_BRIGHTNESS_BRIGHT;
+            packet[0] = (unsigned char)command | (unsigned char)value;
+            retval = send( sock, packet, 1, MSG_OOB );
+            break;
+        case G15DAEMON_MKEYLEDS:
+            packet[0] = (unsigned char)command|(unsigned char)value;
+            retval = send( sock, packet, 1, MSG_OOB );
+            break;
+        case G15DAEMON_SWITCH_PRIORITIES:
+            packet[0] = (unsigned char)command;
+            retval = send( sock, packet, 1, MSG_OOB );
+            break;
+        case G15DAEMON_NEVER_SELECT:
+            packet[0] = (unsigned char)command;
+            retval = send( sock, packet, 1, MSG_OOB );
+            break;
+        case G15DAEMON_GET_KEYSTATE:{
+            retval = 0;
+            unsigned long keystate = 0;
+            g15_recv(sock, (char*)&keystate, sizeof(keystate));
+            return keystate;
+            break;
+        }
+        case G15DAEMON_IS_FOREGROUND:{
+            packet[0] = (unsigned char)command;
+            send( sock, packet, 1, MSG_OOB );
+            retval = g15_recv_oob_answer(sock) - 48;
+            break;
+        }
+        case G15DAEMON_IS_USER_SELECTED:{
+            packet[0] = (unsigned char)command;
+            send( sock, packet, 1, MSG_OOB );
+            retval = g15_recv_oob_answer(sock);
+            break;
+        }       
+        default:
+            return -1;    
+    }
+    usleep(1000);    
+    return retval;       
+}

=== added directory '.pc/07-reinit-on-any-error.diff'
=== added directory '.pc/07-reinit-on-any-error.diff/g15daemon'
=== added file '.pc/07-reinit-on-any-error.diff/g15daemon/main.c'
--- .pc/07-reinit-on-any-error.diff/g15daemon/main.c	1970-01-01 00:00:00 +0000
+++ .pc/07-reinit-on-any-error.diff/g15daemon/main.c	2015-05-21 10:27:39 +0000
@@ -0,0 +1,580 @@
+/*
+    This file is part of g15daemon.
+
+    g15daemon 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.
+
+    g15daemon 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 g15daemon; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    
+    (c) 2006-2008 Mike Lampard, Philip Lawatsch, and others
+    
+    $Revision: 457 $ -  $Date: 2008-01-31 15:32:46 +1030 (Thu, 31 Jan 2008) $ $Author: mlampard $
+    
+    This daemon listens on localhost port 15550 for client connections,
+    and arbitrates LCD display.  Allows for multiple simultaneous clients.
+    Client screens can be cycled through by pressing the 'L1' key.
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <ctype.h>
+
+#include <config.h>
+#include <libg15.h>
+#include <libg15render.h>
+#include "g15daemon.h"
+
+#ifndef LIBG15_VERSION
+#define LIBG15_VERSION 1000
+#endif
+
+/* all threads will exit if leaving >0 */
+volatile int leaving = 0;
+int keyboard_backlight_off_onexit = 0;
+unsigned int g15daemon_debug = 0;
+unsigned int cycle_key;
+unsigned int client_handles_keys = 0;
+static unsigned int set_backlight = 0;
+struct lcd_t *keyhandler = NULL;
+
+static int loaded_plugins = 0;
+
+/* send event to foreground client's eventlistener */
+int g15daemon_send_event(void *caller, unsigned int event, unsigned long value)
+{
+    switch(event) {
+        case G15_EVENT_KEYPRESS: {
+            static unsigned long lastkeys;
+            if(!(value & cycle_key) && !(lastkeys & cycle_key)){
+                lcd_t *lcd = (lcd_t*)caller;
+ 
+                if(!lcd->g15plugin->info)
+                  break;
+ 
+                int *(*plugin_listener)(plugin_event_t *newevent) = (void*)lcd->g15plugin->info->event_handler;
+                plugin_event_t *newevent=g15daemon_xmalloc(sizeof(plugin_event_t));
+                newevent->event = event;
+                newevent->value = value;
+                newevent->lcd = lcd;
+                (*plugin_listener)((void*)newevent);
+        	/* hack - keyboard events are always sent from the foreground even when they aren't 
+                send keypress event to the OS keyboard_handler plugin */
+                if(lcd->masterlist->keyboard_handler != NULL && lcd->masterlist->remote_keyhandler_sock==0) {
+                    int *(*keyboard_handler)(plugin_event_t *newevent) = (void*)lcd->masterlist->keyboard_handler;
+                    (*keyboard_handler)((void*)newevent);
+                }
+                // if we have a remote keyhandler, send the key. FIXME: we should do this from the net plugin
+                if(lcd->masterlist->remote_keyhandler_sock!=0) {
+                          if((send(lcd->masterlist->remote_keyhandler_sock,(void *)&newevent->value,sizeof(newevent->value),0))<0)
+                                              g15daemon_log(LOG_WARNING,"Error in send: %s\n",strerror(errno));
+                }
+                if(value & G15_KEY_LIGHT){ // the backlight key was pressed - maintain user-selected state 
+                  lcd_t *displaying = lcd->masterlist->current->lcd;  
+                  lcd->masterlist->kb_backlight_state++;
+                  lcd->masterlist->kb_backlight_state %= 3;
+                  displaying->backlight_state++;  
+                  displaying->backlight_state %= 3; // limit to 0-2 inclusive 
+                }
+                if(value & G15_KEY_M1 && value & G15_KEY_M3) {
+                  static int scr_num=0;
+                  char filename[128];
+                  lcd_t *displaying = lcd->masterlist->current->lcd;
+                  sprintf(filename,"/tmp/g15daemon-sc-%i.pbm",scr_num);
+                  uf_screendump_pbm(displaying->buf,filename);
+                  scr_num++;
+                }
+                free(newevent);
+            }else{
+                /* hacky attempt to double-time the use of L1, if the key is pressed less than half a second, it cycles the screens.  If held for longer, the key is sent to the application for use instead */
+                lcd_t *lcd = (lcd_t*)caller;
+                g15daemon_t* masterlist = lcd->masterlist;
+                static unsigned int clicktime;
+                
+                if(value & cycle_key) {
+                    clicktime=g15daemon_gettime_ms();
+                }else{
+                    unsigned int unclick=g15daemon_gettime_ms();
+                    if ((unclick-clicktime)<500) {
+                        g15daemon_lcdnode_cycle(masterlist);
+                    }
+                    else 
+                    {
+                        plugin_event_t *clickevent=g15daemon_xmalloc(sizeof(plugin_event_t));
+                        int *(*plugin_listener)(plugin_event_t *clickevent) = (void*)lcd->g15plugin->info->event_handler;
+                        clickevent->event = event;
+                	clickevent->value = value|cycle_key;
+                	clickevent->lcd = lcd;
+                        (*plugin_listener)((void*)clickevent);
+                        clickevent->event = event;
+                	clickevent->value = value&~cycle_key;
+                	clickevent->lcd = lcd;
+                        (*plugin_listener)((void*)clickevent);
+                        free(clickevent);
+                    }
+                }
+            }
+            lastkeys = value;
+            break;
+        }
+        case G15_EVENT_CYCLE_PRIORITY:{
+            lcd_t *lcd = (lcd_t*)caller;
+            g15daemon_t* masterlist = lcd->masterlist;
+            if(value)
+                g15daemon_lcdnode_cycle(masterlist);
+            break;
+        }
+        case G15_EVENT_REQ_PRIORITY: {
+            lcdnode_t *lcdnode=(lcdnode_t*)caller;
+            /* client wants to switch priorities */
+            pthread_mutex_lock(&lcdlist_mutex);
+            if(lcdnode->list->current != lcdnode){
+                lcdnode->last_priority = lcdnode->list->current;
+                lcdnode->list->current = lcdnode;
+            }
+            else {
+                if(lcdnode->list->current == lcdnode->last_priority){
+                    lcdnode->list->current = lcdnode->list->current->prev;
+                } else{
+                    if(lcdnode->last_priority != NULL) {
+                        lcdnode->list->current = lcdnode->last_priority;
+                        lcdnode->last_priority = NULL;
+                    }
+                    else
+                        lcdnode->list->current = lcdnode->list->current->prev;
+                }
+            }
+            pthread_mutex_unlock(&lcdlist_mutex);
+            g15daemon_send_refresh((lcd_t*)lcdnode->list->current->lcd);
+            break;
+        }
+        case G15_EVENT_VISIBILITY_CHANGED:
+            g15daemon_send_refresh((lcd_t*)caller);
+        default: {
+            lcd_t *lcd = (lcd_t*)caller;
+            int *(*plugin_listener)(plugin_event_t *newevent) = (void*)lcd->g15plugin->info->event_handler;
+            plugin_event_t *newevent=g15daemon_xmalloc(sizeof(plugin_event_t));
+            newevent->event = event;
+            newevent->value = value;
+            newevent->lcd = lcd;
+            (*plugin_listener)((void*)newevent);
+            free(newevent);
+        }
+    }
+    return 0;
+}
+
+static void *keyboard_watch_thread(void *lcdlist){
+    
+    g15daemon_t *masterlist = (g15daemon_t*)(lcdlist);
+    
+    unsigned int keypresses = 0;
+    int retval = 0;
+    static int lastkeys = 0;
+
+    while (!leaving) {
+
+        retval = uf_read_keypresses(&keypresses, 20);
+        /* every 2nd packet contains the codes we want.. immediately try again */
+        while (retval == G15_ERROR_TRY_AGAIN){
+            retval = uf_read_keypresses(&keypresses, 20);
+        }
+
+        if(retval == G15_NO_ERROR && lastkeys != keypresses) {
+            g15daemon_send_event(masterlist->current->lcd, 
+                                 G15_EVENT_KEYPRESS, keypresses);
+            lastkeys = keypresses;
+
+        }else if(retval == -ENODEV && LIBG15_VERSION>=1200) {
+          pthread_mutex_lock(&g15lib_mutex);
+          while((retval=re_initLibG15() != G15_NO_ERROR) && !leaving){
+             g15daemon_log(LOG_WARNING,"Keyboard has gone.. Retrying\n");
+             sleep(1);
+          }
+          if(!leaving) { 
+            masterlist->current->lcd->state_changed=1; 
+            g15daemon_send_refresh(masterlist->current->lcd);
+          }
+          pthread_mutex_unlock(&g15lib_mutex); 
+        }
+      g15daemon_msleep(40);
+    }
+    return NULL;
+}
+
+static void *lcd_draw_thread(void *lcdlist){
+
+    g15daemon_t *masterlist = (g15daemon_t*)(lcdlist);
+    /* unsigned int fps = 0; */
+    lcd_t *displaying = masterlist->tail->lcd;
+    memset(displaying->buf,0,1024);
+    static int prev_state=0;
+    g15daemon_sleep(2);
+
+    while (!leaving) {
+        /* wait until a client has updated */
+        g15daemon_wait_refresh();
+
+        pthread_mutex_lock(&lcdlist_mutex);
+        displaying = masterlist->current->lcd;
+                
+        /* monitor 'fps' - due to the TCP protocol, some frames will be bunched up.
+           discard excess to reduce load on the bus */
+        /* fps = 1000 / (g15daemon_gettime_ms() - lastscreentime); */
+        /* if the current screen is less than 20ms from the previous (equivelant to 50fps) delay it */
+        /* this allows a real-world fps of 40fps with no almost frame loss and reduces peak usb bus-load */
+                        
+        g15daemon_log(LOG_DEBUG,"Updating LCD");        
+        uf_write_buf_to_g15(displaying);
+        g15daemon_log(LOG_DEBUG,"LCD Update Complete");
+        
+        if(prev_state!=displaying->backlight_state && set_backlight!=0) {
+              prev_state=displaying->backlight_state;
+              pthread_mutex_lock(&g15lib_mutex);
+              setLCDBrightness(displaying->backlight_state);
+              usleep(5);
+              setLCDBrightness(displaying->backlight_state);
+              setKBBrightness(displaying->backlight_state);
+              pthread_mutex_unlock(&g15lib_mutex);
+        }
+
+        if(displaying->state_changed){
+            pthread_mutex_lock(&g15lib_mutex);
+            setLCDContrast(displaying->contrast_state);
+            if(displaying->masterlist->remote_keyhandler_sock==0) // only allow mled control if the macro recorder isnt running
+              setLEDs(displaying->mkey_state);
+            pthread_mutex_unlock(&g15lib_mutex);
+            displaying->state_changed = 0;
+        }
+            
+        pthread_mutex_unlock(&lcdlist_mutex);
+    }
+    return NULL;
+}
+
+void g15daemon_sighandler(int sig) {
+    switch(sig){
+         case SIGUSR1:
+              keyboard_backlight_off_onexit = 1;
+         case SIGINT:
+         case SIGTERM:
+         case SIGQUIT:
+              leaving = 1;
+               break;
+         case SIGPIPE:
+               break;
+    }
+}
+
+#ifndef HAVE_DAEMON
+/* daemon() is not posix compliant, so we roll our own if needed.*/
+int daemon(int nochdir, int noclose) {
+  pid_t pid;
+  
+  if(nochdir<1)
+    chdir("/");
+  pid = fork();
+
+  switch(pid){
+    case -1:
+     printf("Unable to daemonise!\n");
+     return -1;
+     break;
+    case 0: {
+      umask(0);
+      if(setsid()==-1) {
+       perror("setsid");
+        return -1;
+      }
+      if(noclose<1) {
+        freopen( "/dev/null", "r", stdin);
+        freopen( "/dev/null", "w", stdout);
+        freopen( "/dev/null", "w", stderr);
+      }
+      break;
+    }
+    default:
+      _exit(0);
+  }
+  return 0;
+}
+#endif 
+
+int main (int argc, char *argv[])
+{
+    pid_t daemonpid;
+    int retval;
+    int i;
+    int cycle_cmdline_override=0;
+    struct sigaction new_action;
+    cycle_key = G15_KEY_L1;
+    unsigned char user[256];
+    unsigned int lcdlevel = 1;
+    
+    pthread_t keyboard_thread;
+    pthread_t lcd_thread;
+    memset(user,0,256); 
+
+    for (i=0;i<argc;i++) {
+        char daemonargs[20];
+        memset(daemonargs,0,20);
+        strncpy(daemonargs,argv[i],19);
+        if (!strncmp(daemonargs, "-k",2) || !strncmp(daemonargs, "--kill",6)) {
+                   daemonpid = uf_return_running();
+                   if(daemonpid>0) {
+                       kill(daemonpid,SIGINT);
+                   } else
+                       printf("G15Daemon not running\n");
+ 		   exit(0);
+        }
+        if (!strncmp(daemonargs, "-K",2) || !strncmp(daemonargs, "--KILL",6)) {
+                   daemonpid = uf_return_running();
+                   if(daemonpid>0) {
+                       kill(daemonpid,SIGUSR1);
+                   } else
+                       printf("G15Daemon not running\n");
+ 		   exit(0);
+        }
+        if (!strncmp(daemonargs, "-v",2) || !strncmp(daemonargs, "--version",9)) {
+            float lg15ver = LIBG15_VERSION;
+            printf("G15Daemon version %s - %s\n",VERSION,uf_return_running() >= 0 ?"Loaded & Running":"Not Running");
+            printf("compiled with libg15 version %.3f\n\n",lg15ver/1000);
+            exit(0);
+        }    
+        
+        if (!strncmp(daemonargs, "-h",2) || !strncmp(daemonargs, "--help",6)) {
+            printf("G15Daemon version %s - %s\n",VERSION,uf_return_running() >= 0 ?"Loaded & Running":"Not Running");
+            printf("%s -h (--help) or -k (--kill) or -s (--switch) or -d (--debug) [level] or -v (--version) or -l (--lcdlevel) [0-2] \n\n -k\twill kill a previous incarnation",argv[0]);
+            #ifdef LIBG15_VERSION
+            #if LIBG15_VERSION >= 1200
+            printf("\n -K\tturn off the keyboard backlight on the way out.");
+            #endif
+            #endif
+            printf("\n -h\tshows this help\n -s\tchanges the screen-switch key from L1 to MR (beware)\n -d\tdebug mode - stay in foreground and output all debug messages to STDERR\n -v\tshow version\n -l\tset default LCD backlight level\n");
+            printf(" --set-backlight sets backlight individually for currently shown screen.\n\t\tDefault is to set backlight globally (keyboard default).\n");
+            exit(0);
+        }
+
+        if (!strncmp(daemonargs, "-s",2) || !strncmp(daemonargs, "--switch",8)) {
+            cycle_key = G15_KEY_MR;
+            cycle_cmdline_override=1;
+        }
+
+        if (!strncmp(daemonargs, "--set-backlight",15)) {
+            set_backlight = 1;
+        }
+
+        if (!strncmp(daemonargs, "-d",2) || !strncmp(daemonargs, "--debug",7)) {
+            g15daemon_debug = 1;
+            if((argv[i+1])!=NULL)
+             if(isdigit(argv[i+1][0])){
+              g15daemon_debug = atoi(argv[i+1]);
+              if(g15daemon_debug==0) g15daemon_debug = 1;
+            }
+        }
+        
+        if (!strncmp(daemonargs, "-u",2) || !strncmp(daemonargs, "--user",7)) {
+            if(argv[i+1]!=NULL){
+                strncpy((char*)user,argv[i+1],128);
+                i++;
+            }
+        }
+
+        if (!strncmp(daemonargs, "-l",2) || !strncmp(daemonargs, "--lcdlevel",7)) {
+            if((argv[i+1])!=NULL)
+             if(isdigit(argv[i+1][0])){
+              lcdlevel = atoi(argv[i+1]);
+            }
+        }
+    }
+    if(g15daemon_debug){
+        g15daemon_log(LOG_INFO, "G15Daemon %s Build Date: %s",PACKAGE_VERSION,BUILD_DATE);
+        g15daemon_log(LOG_DEBUG, "Build OS: %s",BUILD_OS_NAME);
+        g15daemon_log(LOG_DEBUG, "With compiler: %s",COMPILER_VERSION);
+        fprintf(stderr, "G15Daemon CMDLINE ARGS: ");
+        for(i=1;i<argc;i++)
+          fprintf(stderr, "%s ",argv[i]);
+          fprintf(stderr,"\n");
+    }
+    if(uf_return_running()>=0) {
+        g15daemon_log(LOG_ERR,"G15Daemon already running.. Exiting");
+        exit(0);
+    }
+
+    /* set libg15 debugging to our debug setting */
+    if(LIBG15_VERSION>=1200)
+        libg15Debug(g15daemon_debug);
+    
+#ifdef OSTYPE_DARWIN
+     /* OS X: load codeless kext */
+     retval = system("/sbin/kextload " "/System/Library/Extensions/libusbshield.kext");
+		
+     if (WIFEXITED(retval)){
+	if (WEXITSTATUS(retval) !=0){
+		g15daemon_log(LOG_ERR,"Unable to load USB shield kext...exiting");
+		exit(1);
+        }
+     } else {
+	g15daemon_log(LOG_ERR,"Unable to launch kextload...exiting");
+	exit(1);
+     }
+#endif
+
+    /* init stuff here..  */
+    if((retval=initLibG15())!=G15_NO_ERROR){
+        g15daemon_log(LOG_ERR,"Unable to attach to the G15 Keyboard... exiting");
+        exit(1);
+    }
+
+    if(!g15daemon_debug)
+        daemon(0,0);
+
+    if(uf_create_pidfile() == 0) {
+        
+        g15daemon_t *lcdlist;
+        config_section_t *global_cfg=NULL;
+        pthread_attr_t attr;
+        struct passwd *nobody;
+        unsigned char location[1024];
+
+        openlog("g15daemon", LOG_PID, LOG_DAEMON);
+        if(strlen((char*)user)==0){
+            nobody = getpwnam("nobody");
+        }else {
+            nobody = getpwnam((char*)user);
+        }
+        if (nobody==NULL)
+        {
+            nobody = getpwuid(geteuid());
+            g15daemon_log(LOG_WARNING,"BEWARE: running as effective uid %i\n",nobody->pw_uid);
+        }
+        
+        /* initialise the linked list */
+        lcdlist = ll_lcdlist_init();
+        lcdlist->nobody = nobody;
+
+        setLCDContrast(1); 
+        setLEDs(0);
+        lcdlist->kb_backlight_state=1;
+        lcdlist->current->lcd->backlight_state=lcdlevel;
+        setLCDBrightness(lcdlevel);
+
+#ifdef LIBG15_VERSION
+#if LIBG15_VERSION >= 1200
+        setKBBrightness(lcdlist->kb_backlight_state);
+#endif
+#endif                      
+        
+        uf_conf_open(lcdlist, "/etc/g15daemon.conf");
+        global_cfg=g15daemon_cfg_load_section(lcdlist,"Global");
+        if(!cycle_cmdline_override){
+            cycle_key = 1==g15daemon_cfg_read_bool(global_cfg,"Use MR as Cycle Key",0)?G15_KEY_MR:G15_KEY_L1;
+        }
+
+#ifndef OSTYPE_SOLARIS
+               /* all other processes/threads should be seteuid nobody */
+        if(nobody!=NULL) {
+            seteuid(nobody->pw_uid);
+            setegid(nobody->pw_gid);
+        }
+#endif
+        /* initialise the pthread condition for the LCD thread */
+        g15daemon_init_refresh(); 
+        pthread_mutex_init(&g15lib_mutex, NULL);
+        pthread_attr_init(&attr);
+
+        pthread_attr_setstacksize(&attr,512*1024); /* set stack to 512k - dont need 8Mb !! */
+        if (pthread_create(&keyboard_thread, &attr, keyboard_watch_thread, lcdlist) != 0) {
+            g15daemon_log(LOG_ERR,"Unable to create keyboard listener thread.  Exiting");
+            goto exitnow;
+        }
+
+        pthread_attr_setstacksize(&attr,128*1024); 
+
+        if (pthread_create(&lcd_thread, &attr, lcd_draw_thread, lcdlist) != 0) {
+            g15daemon_log(LOG_ERR,"Unable to create display thread.  Exiting");
+            goto exitnow;
+        }
+        g15daemon_log(LOG_INFO,"%s loaded\n",PACKAGE_STRING);
+        
+        snprintf((char*)location,1024,"%s/%s",DATADIR,"g15daemon/splash/g15logo2.wbmp");
+	g15canvas *canvas = (g15canvas *)g15daemon_xmalloc (sizeof (g15canvas));
+	memset (canvas->buffer, 0, G15_BUFFER_LEN);
+	canvas->mode_cache = 0;
+	canvas->mode_reverse = 0;
+	canvas->mode_xor = 0;
+        g15r_loadWbmpSplash(canvas,(char*)location);
+	memcpy (lcdlist->tail->lcd->buf, canvas->buffer, G15_BUFFER_LEN);
+	free (canvas);
+        uf_write_buf_to_g15(lcdlist->tail->lcd);
+	
+        snprintf((char*)location,1024,"%s",PLUGINDIR);
+
+        loaded_plugins = g15_open_all_plugins(lcdlist,(char*)location);
+        
+        new_action.sa_handler = g15daemon_sighandler;
+        new_action.sa_flags = 0;
+        sigaction(SIGINT, &new_action, NULL);
+    	sigaction(SIGQUIT, &new_action, NULL);
+    	sigaction(SIGTERM, &new_action, NULL);
+    	sigaction(SIGUSR1, &new_action, NULL);
+        
+        do {
+            pause();
+        } while( leaving == 0);
+
+        g15daemon_log(LOG_INFO,"Leaving by request");
+
+        pthread_join(lcd_thread,NULL);
+        pthread_join(keyboard_thread,NULL);
+        /* switch off the lcd backlight */
+        char *blank=g15daemon_xmalloc(G15_BUFFER_LEN);
+        writePixmapToLCD((unsigned char*)blank);
+        free(blank);
+        setLCDBrightness(0);
+#ifdef LIBG15_VERSION
+#if LIBG15_VERSION >= 1200
+        /* if SIGUSR1 was sent to kill us, switch off the keyboard backlight as well */
+        if(keyboard_backlight_off_onexit==1)
+          setKBBrightness(0);
+#endif
+#endif
+            
+#ifdef LIBG15_VERSION
+#if LIBG15_VERSION >= 1100
+        exitLibG15(); 
+#endif
+#endif
+        ll_lcdlist_destroy(&lcdlist);
+
+exitnow:
+    /* return to root privilages for the final countdown */
+    seteuid(0);
+    setegid(0);
+    closelog();
+    g15daemon_quit_refresh();
+    uf_conf_write(lcdlist,"/etc/g15daemon.conf");
+    uf_conf_free(lcdlist);
+    unlink("/var/run/g15daemon.pid");
+    }
+    return 0;
+}

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2015-05-21 10:27:39 +0000
@@ -0,0 +1,7 @@
+01-remove-x11-setup-from-man.diff
+02-better-screenshort-creation.diff
+03-change-syslog-facility.diff
+04-open-needs-mode.diff
+05-send-a-sync-event-after-key-up-down.diff
+06-fix-buffer-overflow.diff
+07-reinit-on-any-error.diff

=== modified file 'debian/changelog'
--- debian/changelog	2014-05-20 02:13:35 +0000
+++ debian/changelog	2015-05-21 10:27:39 +0000
@@ -1,3 +1,30 @@
+g15daemon (1.9.5.3-8.3ubuntu1ppa2) UNRELEASED; urgency=medium
+
+  * debian/g15daemon.service: Added documantation link.
+
+ -- Alexander Ponyatykh <[e-mail]>  Thu, 21 May 2015 12:41:54 +0300
+
+g15daemon (1.9.5.3-8.3ubuntu1ppa1) wily; urgency=medium
+
+  * Converted source to 3.0 (quilt) format.
+  * debian/g15daemon.init: Replaced /dev/input/uinput with /dev/uinput
+    (related to LP #617101).
+  * debian/docs: removed obsolete file.
+  * Do not fail package installation/removal if g15daemon fails to start/stop
+    (LP: #617101, LP: #1103275).
+  * debian/g15daemon.init: added dependency on $remote_fs
+  * debian/g15daemon.init: now sources /lib/lsb/init-functions
+  * Added debian/patches/07-reinit-on-any-error.diff: reinitialize on any
+    error returned by libusb to correctly recover after suspend/resume.
+    (LP: #1357556)
+  * debian/control: removed dependency on libg15daemon-client1 for g15daemon
+  * debian/control: changed priority of g15daemon to optional
+  * Added native upstart job and systemd service. (LP: #1441365)
+  * debian/g15daemon.default: removed SWITCH_KEY option to keep systemd and
+    upstart scripts simple.
+
+ -- Alexander Ponyatykh <[e-mail]>  Thu, 21 May 2015 11:16:21 +0300
+
 g15daemon (1.9.5.3-8.3ubuntu1) utopic; urgency=medium
 
   * Merge from Debian unstable. Remaining changes:

=== modified file 'debian/control'
--- debian/control	2014-05-20 02:13:35 +0000
+++ debian/control	2015-05-21 10:27:39 +0000
@@ -1,18 +1,19 @@
 Source: g15daemon
 Section: utils
-Priority: extra
+Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 XSBC-Original-Maintainer: Giacomo Catenazzi <[e-mail]>
 Build-Depends: cdbs, debhelper (>= 5), dh-autoreconf, libtool, chrpath,
  libg15-dev, libg15render-dev (>=1.2.0.svn250-2), libusb-dev, libfreetype6-dev
-Standards-Version: 3.8.2
+Standards-Version: 3.9.6
 Homepage: http://www.g15tools.com/
 
 Package: g15daemon
 Section: utils
 Architecture: any
-Depends: libg15daemon-client1 (=${binary:Version}), ${shlibs:Depends}, ${misc:Depends},
-Recommends: xkb-data ( >= 0.9+cvs.20070428-1)
+Depends: ${shlibs:Depends}, ${misc:Depends}, lsb-base (>= 4.1+Debian3),
+ sysv-rc (>= 2.88dsf-24)
+Recommends: xkb-data ( >= 0.9+cvs.20070428-1), udev
 Description:  Screen multiplexer for Logitech G15 Keyboard
  G15daemon provides multiple virtual screens for the LCD on the Logitech
  G11 and G15 keyboards.
@@ -22,7 +23,6 @@
 
 Package: libg15daemon-client1
 Section: libs
-Priority: optional
 Architecture: any
 Depends: ${shlibs:Depends}, ${misc:Depends}
 Description: Development packages for libg15daemon-client
@@ -30,6 +30,7 @@
 
 Package: libg15daemon-client-dev
 Section: libdevel
+Priority: extra
 Architecture: any
 Depends: libg15daemon-client1 (= ${binary:Version}), ${misc:Depends}
 Description: Development packages for libg15daemon-client

=== removed file 'debian/docs'
--- debian/docs	2009-08-06 08:32:33 +0000
+++ debian/docs	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-NEWS
-README
-TODO

=== modified file 'debian/g15daemon.default'
--- debian/g15daemon.default	2009-08-19 07:33:22 +0000
+++ debian/g15daemon.default	2015-05-21 10:27:39 +0000
@@ -1,13 +1,5 @@
 # Defaults for g15daemon initscript
 
-# SWITCH_KEY selects  the key used to switch between client screens
-#
-# SWITCH_KEY="MR"   to use the MR key (on top left)
-# SWITCH_KEY="L1    to use the L1 key: the small round key below the LCD
-
-
-SWITCH_KEY="L1"
-
 # Turn on debugging of g15 init.d and udev scripts
 #G15DEBUG="on"
 

=== modified file 'debian/g15daemon.init'
--- debian/g15daemon.init	2009-08-19 07:33:22 +0000
+++ debian/g15daemon.init	2015-05-21 10:27:39 +0000
@@ -2,8 +2,8 @@
 
 ### BEGIN INIT INFO
 # Provides:          g15daemon
-# Required-Start:    $syslog $local_fs
-# Required-Stop:     $syslog $local_fs
+# Required-Start:    $syslog $local_fs $remote_fs
+# Required-Stop:     $syslog $local_fs $remote_fs
 # Should-Start:      $remote_fs
 # Should-Stop:       $remote_fs
 # X-Start-Before:    xdm kdm gdm ldm sdm
@@ -21,6 +21,8 @@
 
 [ -x "$DAEMON" ] || exit 0
 
+. /lib/lsb/init-functions
+
 # Include g15daemon defaults if available
 if [ -f /etc/default/g15daemon ] ; then
 	. /etc/default/g15daemon
@@ -45,8 +47,11 @@
 
 fi
 
-
-
+check_new_init() {
+    if init_is_upstart || ps -p1 | grep -q systemd ; then
+        exit $1
+    fi
+}
 
 wait_for_file() {
         local file=$1
@@ -63,9 +68,9 @@
 }
 
 load_uinput() {
-    if [ ! -e /dev/input/uinput ] ; then
+    if [ ! -e /dev/uinput ] ; then
         modprobe -q uinput || true
-	wait_for_file /dev/input/uinput 3  ||  return 1
+	wait_for_file /dev/uinput 3  ||  return 1
     fi
 }
 
@@ -94,12 +99,14 @@
 
 case "$1" in
   start)
+	check_new_init 1
 	echo -n "Starting $DESC: "
-	load_uinput || echo -n ".../dev/input/uinput not found ..."
+	load_uinput || echo -n ".../dev/uinput not found ..."
 	do_start
 	echo "$NAME."
 	;;
   stop)
+	check_new_init 0
 	echo -n "Stopping $DESC: "
 	do_stop
 	echo "$NAME."
@@ -123,9 +130,11 @@
 	#	just the same as "restart" except that it does nothing if the
 	#   daemon isn't already running.
 	# check wether $DAEMON is running. If so, restart
+	check_new_init 1
 	is_running  &&  $0 restart  ||  exit 0
         ;;
   restart)
+	check_new_init 1
     echo -n "Restarting $DESC: "
 	do_stop
 	# the device is slow to shut-down
@@ -134,6 +143,7 @@
 	echo "$NAME."
 	;;
   udev)
+	check_new_init 0
 	log "calling g15 udev; action: $ACTION, product $PRODUCT"
 	if [ "x$ACTION" = "xadd" ] ; then
 	    load_uinput || true
@@ -153,6 +163,7 @@
   shared-udev)
         # some devices share usb also for audio, which causes some spourios
         # udev messages.
+	check_new_init 0
         log "calling g15 shared-dev; action: $ACTION, product $PRODUCT"
         if [ "x$ACTION" = "xadd" ] ; then
             load_uinput || true

=== added file 'debian/g15daemon.postinst'
--- debian/g15daemon.postinst	1970-01-01 00:00:00 +0000
+++ debian/g15daemon.postinst	2015-05-21 10:27:39 +0000
@@ -0,0 +1,8 @@
+#!/bin/sh -e
+
+#DEBHELPER#
+
+if [ "$1" = configure ] ; then
+    #g15daemon will fail if supported device is not present, so ignore start script errors
+    invoke-rc.d g15daemon start || true
+fi

=== added file 'debian/g15daemon.prerm'
--- debian/g15daemon.prerm	1970-01-01 00:00:00 +0000
+++ debian/g15daemon.prerm	2015-05-21 10:27:39 +0000
@@ -0,0 +1,5 @@
+#!/bin/sh -e
+
+#DEBHELPER#
+
+invoke-rc.d g15daemon stop || true

=== added file 'debian/g15daemon.service'
--- debian/g15daemon.service	1970-01-01 00:00:00 +0000
+++ debian/g15daemon.service	2015-05-21 10:27:39 +0000
@@ -0,0 +1,12 @@
+[Unit]
+Description=Daemon for Logitech G15 keyboard
+Documentation=man:g15daemon(1)
+Wants=remote-fs.target
+After=remote-fs.target
+
+[Service]
+Type=forking
+EnvironmentFile=-/etc/default/g15daemon
+ExecStartPre=-/sbin/modprobe -q uinput
+ExecStartPre=-/sbin/udevadm settle -t 5 -E /dev/uinput
+ExecStart=/usr/sbin/g15daemon $DAEMON_OPTS

=== modified file 'debian/g15daemon.udev'
--- debian/g15daemon.udev	2011-05-31 07:33:52 +0000
+++ debian/g15daemon.udev	2015-05-21 10:27:39 +0000
@@ -4,17 +4,16 @@
 #
 
 # Logitech g11 -- extra keys, no LCD
-ATTR{idVendor}=="046d", ATTR{idProduct}=="c225", RUN+="/etc/init.d/g15daemon udev"
+ATTR{idVendor}=="046d", ATTR{idProduct}=="c225", RUN+="/etc/init.d/g15daemon udev", TAG+="systemd",ENV{SYSTEMD_WANTS}+="g15daemon.service"
 
 # Logitech G15 (blue) -- extra keys and LCD
-ATTR{idVendor}=="046d", ATTR{idProduct}=="c222", RUN+="/etc/init.d/g15daemon udev"
+ATTR{idVendor}=="046d", ATTR{idProduct}=="c222", RUN+="/etc/init.d/g15daemon udev", TAG+="systemd", ENV{SYSTEMD_WANTS}+="g15daemon.service"
 
 # Logitech G15 v2 (orange) -- extra keys and LCD
-ATTR{idVendor}=="046d", ATTR{idProduct}=="c227", RUN+="/etc/init.d/g15daemon shared-udev"
+ATTR{idVendor}=="046d", ATTR{idProduct}=="c227", RUN+="/etc/init.d/g15daemon shared-udev", TAG+="systemd", ENV{SYSTEMD_WANTS}+="g15daemon.service"
 
 # Logitech Z10 -- extra keys and LCD
-ATTR{idVendor}=="046d", ATTR{idProduct}=="0a07", RUN+="/etc/init.d/g15daemon udev"
+ATTR{idVendor}=="046d", ATTR{idProduct}=="0a07", RUN+="/etc/init.d/g15daemon udev", TAG+="systemd", ENV{SYSTEMD_WANTS}+="g15daemon.service"
 
 # Logitech G15 Gamepanel -- extra keys and LCD
-ATTR{idVendor}=="046d", ATTR{idProduct}=="c251", RUN+="/etc/init.d/g15daemon shared-udev"
-
+ATTR{idVendor}=="046d", ATTR{idProduct}=="c251", RUN+="/etc/init.d/g15daemon shared-udev", TAG+="systemd", ENV{SYSTEMD_WANTS}+="g15daemon.service"

=== added file 'debian/g15daemon.upstart'
--- debian/g15daemon.upstart	1970-01-01 00:00:00 +0000
+++ debian/g15daemon.upstart	2015-05-21 10:27:39 +0000
@@ -0,0 +1,20 @@
+#Daemon for Logitech G15 keyboard
+
+start on remote-filesystems and (
+    usb-device-added ID_VENDOR_ID=046d ID_MODEL_ID=c225 or
+    usb-device-added ID_VENDOR_ID=046d ID_MODEL_ID=c222 or
+    usb-device-added ID_VENDOR_ID=046d ID_MODEL_ID=c227 or
+    usb-device-added ID_VENDOR_ID=046d ID_MODEL_ID=0a07 or
+    usb-device-added ID_VENDOR_ID=046d ID_MODEL_ID=c251)
+
+stop on runlevel [016]
+
+expect fork
+
+pre-start script
+    /sbin/modprobe -q uinput || true
+    [ -f /etc/default/g15daemon ] && . /etc/default/g15daemon
+    /sbin/udevadm settle -t 5 -E /dev/uinput || true
+end script
+
+exec /usr/sbin/g15daemon $DAEMON_OPTS

=== added directory 'debian/patches'
=== added file 'debian/patches/01-remove-x11-setup-from-man.diff'
--- debian/patches/01-remove-x11-setup-from-man.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/01-remove-x11-setup-from-man.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,127 @@
+--- a/Documentation/g15daemon.1
++++ b/Documentation/g15daemon.1
+@@ -37,113 +37,6 @@
+ If all required libraries are installed and in locations known to your operating system, the daemon will slip quietly into the background and a clock will appear on the LCD.  
+ Congratulations!  The linux kernel will now output keycodes for all your extra keys.
+ 
+-.SH "Using the keys in X11"
+-Current versions of the Xorg Xserver dont have support for the extra keys that g15daemon provides.  This support will be available in the next release of Xorg (7.2).
+-
+-For now, if you want access to the extra keys for hotkey support in X11, you need to run the xmodmaprc script on each start of X.  This script is available in the contrib folder (if g15daemon is installed in the default location, the contrib folder is in /usr/share/doc/g15daemon\-${VERSION}/contrib 
+-
+-Depending on your linux distribution, copying the xmodmaprc file (or pasting the text below) into ~/.Xmodmap may be all that's required.
+-
+-.SH "Xmodmaprc file"
+-Copy the following into ~/.Xmodmap (depending on your distribution) for X11 to recognise all extra G15 keys:
+-
+-\-\- cut here \-\-
+-.br
+-keycode  93 = XF86Launch1
+-.br
+-keycode 129 = XF86Launch8
+-.br
+-keycode 130 = XF86Launch9
+-.br
+-keycode 131 = XF86Launch2
+-.br
+-keycode 132 = XF86Phone
+-.br
+-keycode 133 = XF86Messenger
+-.br
+-keycode 136 = XF86LaunchD
+-.br
+-keycode 137 = XF86Support
+-.br
+-keycode 138 = XF86Word
+-.br
+-keycode 143 = XF86LaunchF
+-.br
+-keycode 144 = XF86AudioPrev
+-.br
+-keycode 150 = XF86LogOff
+-.br
+-keycode 152 = XF86Launch5
+-.br
+-keycode 153 = XF86AudioNext
+-.br
+-keycode 160 = XF86AudioMute
+-.br
+-keycode 161 = XF86Travel
+-.br
+-keycode 162 = XF86AudioPlay
+-.br
+-keycode 163 = XF86Spell
+-.br
+-keycode 164 = XF86AudioStop
+-.br
+-keycode 170 = XF86VendorHome
+-.br
+-keycode 174 = XF86AudioLowerVolume
+-.br
+-keycode 176 = XF86AudioRaiseVolume
+-.br
+-keycode 177 = XF86Launch4
+-.br
+-keycode 178 = XF86HomePage
+-.br
+-keycode 182 = XF86Away
+-.br
+-keycode 183 = XF86WebCam
+-.br
+-keycode 184 = XF86Launch0
+-.br
+-keycode 188 = XF86Music
+-.br
+-keycode 190 = XF86Launch6
+-.br
+-keycode 194 = XF86Forward
+-.br
+-keycode 195 = XF86Send
+-.br
+-keycode 205 = XF86Calendar
+-.br
+-keycode 208 = XF86Launch7
+-.br
+-keycode 209 = XF86LaunchB
+-.br
+-keycode 210 = XF86LaunchC
+-.br
+-keycode 215 = XF86Save
+-.br
+-keycode 219 = XF86WWW
+-.br
+-keycode 220 = XF86LaunchE
+-.br
+-keycode 223 = XF86Sleep
+-.br
+-keycode 228 = XF86Pictures
+-.br
+-keycode 231 = XF86LaunchA
+-.br
+-keycode 236 = XF86Mail
+-.br
+-keycode 237 = XF86AudioMedia
+-.br
+-keycode 246 = XF86iTouch
+-.br
+-keycode 247 = XF86Launch3
+-.br
+-keycode 249 = XF86ToDoList
+-.br
+-keycode 251 = XF86Calculater
+-.br
+-\-\- end cutting \-\-
+ .SH "AUTHORS"
+ The latest release of g15daemon is available at
+ .P
+--- a/Documentation/g15daemon_client_devel.3
++++ b/Documentation/g15daemon_client_devel.3
+@@ -55,7 +55,7 @@
+ int retval = 0;
+ int screen_fd = new_g15_screen( G15_WBMPBUF );
+ 
+-... do processing and display here ...
++ ... do processing and display here ...
+ 
+ retval = g15_close_screen( screen_fd );
+ 

=== added file 'debian/patches/02-better-screenshort-creation.diff'
--- debian/patches/02-better-screenshort-creation.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/02-better-screenshort-creation.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,39 @@
+--- a/g15daemon/utility_funcs.c
++++ b/g15daemon/utility_funcs.c
+@@ -666,12 +666,24 @@
+ }
+ 
+ int uf_screendump_pbm(unsigned char *buffer,char *filename) {
++    int fd;
+     FILE *f;
+     int x,y;
+     #define WIDTH 40
+     g15canvas *canvas=g15daemon_xmalloc(sizeof(g15canvas));
+     memcpy(canvas->buffer,buffer,LCD_BUFSIZE);
+-    f = fopen(filename,"w+");
++    fd = open(filename, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
++    if(fd == -1) {
++       g15daemon_log(LOG_WARNING, "uf_screendump_pbm failed: open, %s.\n", strerror(errno));
++       return -1;
++    }
++    f = fdopen(fd,"w");
++    if(f==NULL) {
++       close(fd);
++        g15daemon_log(LOG_WARNING, "uf_screendump_pbm failed: fdopen, %s.\n", strerror(errno));
++        return -1;
++    }
++
+     fprintf(f,"P1\n160 43\n");
+     fprintf(f,"# G15 screendump - %s\n\n",filename);
+     for(y=0;y<43;y++)
+@@ -681,7 +693,9 @@
+               fprintf(f,"\n");
+         }
+ 
+-        fclose(f);
++    fclose(f);
++    fsync(fd);
++    close(fd);
+     free(canvas);
+     return 0;
+ }

=== added file 'debian/patches/03-change-syslog-facility.diff'
--- debian/patches/03-change-syslog-facility.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/03-change-syslog-facility.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,11 @@
+--- a/g15daemon/main.c
++++ b/g15daemon/main.c
+@@ -456,7 +456,7 @@
+         struct passwd *nobody;
+         unsigned char location[1024];
+ 
+-        openlog("g15daemon", LOG_PID, LOG_USER);
++        openlog("g15daemon", LOG_PID, LOG_DAEMON);
+         if(strlen((char*)user)==0){
+             nobody = getpwnam("nobody");
+         }else {

=== added file 'debian/patches/04-open-needs-mode.diff'
--- debian/patches/04-open-needs-mode.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/04-open-needs-mode.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,11 @@
+--- a/g15daemon/utility_funcs.c
++++ b/g15daemon/utility_funcs.c
+@@ -356,7 +356,7 @@
+     config_items_t * item=NULL;
+     char line[1024];
+     
+-    config_fd = open(filename,O_CREAT|O_RDWR|O_TRUNC);
++    config_fd = open(filename,O_CREAT|O_RDWR|O_TRUNC, 0644);
+     if(config_fd){
+     snprintf(line,1024,"# G15Daemon Configuration File\n# any items entered before a [section] header\n# will be in the Global config space\n# comments you wish to keep should start with a semicolon';'\n");
+     write(config_fd,line,strlen(line));

=== added file 'debian/patches/05-send-a-sync-event-after-key-up-down.diff'
--- debian/patches/05-send-a-sync-event-after-key-up-down.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/05-send-a-sync-event-after-key-up-down.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,30 @@
+--- a/plugins/g15_plugin_uinput.c
++++ b/plugins/g15_plugin_uinput.c
+@@ -125,6 +125,13 @@
+     event.value = G15KEY_DOWN;
+     
+     write (uinp_fd, &event, sizeof(event));
++
++    memset(&event, 0, sizeof(event));
++
++    event.type = EV_SYN;
++    event.code = SYN_REPORT;
++
++    write (uinp_fd, &event, sizeof(event));
+ }
+ 
+ static void g15_uinput_keyup(unsigned char code)
+@@ -137,6 +144,13 @@
+     event.value = G15KEY_UP;
+     
+     write (uinp_fd, &event, sizeof(event));
++
++    memset(&event, 0, sizeof(event));
++
++    event.type = EV_SYN;
++    event.code = SYN_REPORT;
++
++    write (uinp_fd, &event, sizeof(event));
+ }
+ 
+     void (*keyup)(unsigned char code) = &g15_uinput_keyup;

=== added file 'debian/patches/06-fix-buffer-overflow.diff'
--- debian/patches/06-fix-buffer-overflow.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/06-fix-buffer-overflow.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,11 @@
+--- a/libg15daemon_client/g15daemon_net.c
++++ b/libg15daemon_client/g15daemon_net.c
+@@ -217,7 +217,7 @@
+     if(poll(pfd,1,100)>0){
+        if(pfd[0].revents & POLLPRI && !(pfd[0].revents & POLLERR || pfd[0].revents & POLLHUP || pfd[0].revents & POLLNVAL)) { 
+              memset(packet,0,sizeof(packet));
+-             msgret = recv(sock, packet, 10 , MSG_OOB);
++             msgret = recv(sock, packet, sizeof(packet) , MSG_OOB);
+              if (msgret < 1) {
+                   return -1;
+               }

=== added file 'debian/patches/07-reinit-on-any-error.diff'
--- debian/patches/07-reinit-on-any-error.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/07-reinit-on-any-error.diff	2015-05-21 10:27:39 +0000
@@ -0,0 +1,22 @@
+Description: Reinitialize on any libusb error.
+ This allows g15daemon to correctly recover after suspend/resume.
+Author: Alexander Ponyatykh <[e-mail]>
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/libusb/+bug/1357556
+Forwarded: no
+Last-Update: 2015-05-18
+===================================================================
+--- a/g15daemon/main.c
++++ b/g15daemon/main.c
+@@ -204,10 +204,10 @@
+                                  G15_EVENT_KEYPRESS, keypresses);
+             lastkeys = keypresses;
+ 
+-        }else if(retval == -ENODEV && LIBG15_VERSION>=1200) {
++        }else if(retval < 0 && LIBG15_VERSION>=1200) {
+           pthread_mutex_lock(&g15lib_mutex);
+           while((retval=re_initLibG15() != G15_NO_ERROR) && !leaving){
+-             g15daemon_log(LOG_WARNING,"Keyboard has gone.. Retrying\n");
++             g15daemon_log(LOG_WARNING,"Keyboard error (%d).. Reinitializing\n", retval);
+              sleep(1);
+           }
+           if(!leaving) { 

=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2015-05-21 10:27:39 +0000
@@ -0,0 +1,7 @@
+01-remove-x11-setup-from-man.diff
+02-better-screenshort-creation.diff
+03-change-syslog-facility.diff
+04-open-needs-mode.diff
+05-send-a-sync-event-after-key-up-down.diff
+06-fix-buffer-overflow.diff
+07-reinit-on-any-error.diff

=== modified file 'debian/rules'
--- debian/rules	2014-01-15 03:41:51 +0000
+++ debian/rules	2015-05-21 10:27:39 +0000
@@ -27,6 +27,7 @@
 include /usr/share/cdbs/1/rules/autoreconf.mk
 
 DEB_CONFIGURE_EXTRA_FLAGS = --quiet --disable-rpath
+DEB_DH_INSTALLINIT_ARGS_g15daemon = --no-start --no-restart-on-upgrade
 
 install/libg15daemon-client1::
 	chrpath --delete $(DEB_DESTDIR)/usr/lib/libg15daemon_client.so.1.0.2 $(DEB_DESTDIR)/usr/lib/g15daemon/1.9.5.3/plugins/*.so $(DEB_DESTDIR)/usr/sbin/g15daemon

=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2015-05-21 10:27:39 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)

=== modified file 'g15daemon/main.c'
--- g15daemon/main.c	2009-12-18 07:52:26 +0000
+++ g15daemon/main.c	2015-05-21 10:27:39 +0000
@@ -204,10 +204,10 @@
                                  G15_EVENT_KEYPRESS, keypresses);
             lastkeys = keypresses;
 
-        }else if(retval == -ENODEV && LIBG15_VERSION>=1200) {
+        }else if(retval < 0 && LIBG15_VERSION>=1200) {
           pthread_mutex_lock(&g15lib_mutex);
           while((retval=re_initLibG15() != G15_NO_ERROR) && !leaving){
-             g15daemon_log(LOG_WARNING,"Keyboard has gone.. Retrying\n");
+             g15daemon_log(LOG_WARNING,"Keyboard error (%d).. Reinitializing\n", retval);
              sleep(1);
           }
           if(!leaving) {