uSynergy.c

Go to the documentation of this file.

/*
uSynergy client -- Implementation for the embedded Synergy client library
  version 1.0.0, July 7th, 2012
 
Copyright (c) 2012 Alex Evans
 
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
 
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
 
   1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgment in the product documentation would be
   appreciated but is not required.
 
   2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.
 
   3. This notice may not be removed or altered from any source
   distribution.
*/
#include "uSynergy.h"
#include <stdio.h>
#include <string.h>
 
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Internal helpers
//---------------------------------------------------------------------------------------------------------------------
 
 
 
static int16_t sNetToNative16(const unsigned char *value)
{
#ifdef USYNERGY_LITTLE_ENDIAN
        return value[1] | (value[0] << 8);
#else
        return value[0] | (value[1] << 8);
#endif
}
 
 
 
static int32_t sNetToNative32(const unsigned char *value)
{
#ifdef USYNERGY_LITTLE_ENDIAN
        return value[3] | (value[2] << 8) | (value[1] << 16) | (value[0] << 24);
#else
        return value[0] | (value[1] << 8) | (value[2] << 16) | (value[3] << 24);
#endif
}
 
 
 
static void sTrace(uSynergyContext *context, const char* text)
{
        // Don't trace if we don't have a trace function
        if (context->m_traceFunc != 0L)
                context->m_traceFunc(context->m_cookie, text);
}
 
 
 
static void sAddString(uSynergyContext *context, const char *string)
{
        size_t len = strlen(string);
        memcpy(context->m_replyCur, string, len);
        context->m_replyCur += len;
}
 
 
 
static void sAddUInt8(uSynergyContext *context, uint8_t value)
{
        *context->m_replyCur++ = value;
}
 
 
 
static void sAddUInt16(uSynergyContext *context, uint16_t value)
{
        uint8_t *reply = context->m_replyCur;
        *reply++ = (uint8_t)(value >> 8);
        *reply++ = (uint8_t)value;
        context->m_replyCur = reply;
}
 
 
 
static void sAddUInt32(uSynergyContext *context, uint32_t value)
{
        uint8_t *reply = context->m_replyCur;
        *reply++ = (uint8_t)(value >> 24);
        *reply++ = (uint8_t)(value >> 16);
        *reply++ = (uint8_t)(value >> 8);
        *reply++ = (uint8_t)value;
        context->m_replyCur = reply;
}
 
 
 
static uSynergyBool sSendReply(uSynergyContext *context)
{
        // Set header size
        uint8_t         *reply_buf      = context->m_replyBuffer;
        uint32_t        reply_len       = (uint32_t)(context->m_replyCur - reply_buf);                          /* Total size of reply */
        uint32_t        body_len        = reply_len - 4;                                                                                        /* Size of body */
        uSynergyBool ret;
        reply_buf[0] = (uint8_t)(body_len >> 24);
        reply_buf[1] = (uint8_t)(body_len >> 16);
        reply_buf[2] = (uint8_t)(body_len >> 8);
        reply_buf[3] = (uint8_t)body_len;
 
        // Send reply
        ret = context->m_sendFunc(context->m_cookie, context->m_replyBuffer, reply_len);
 
        // Reset reply buffer write pointer
        context->m_replyCur = context->m_replyBuffer+4;
        return ret;
}
 
 
 
static void sSendMouseCallback(uSynergyContext *context)
{
        // Skip if no callback is installed
        if (context->m_mouseCallback == 0L)
                return;
 
        // Send callback
        context->m_mouseCallback(context->m_cookie, context->m_mouseX, context->m_mouseY, context->m_mouseWheelX,
                context->m_mouseWheelY, context->m_mouseButtonLeft, context->m_mouseButtonRight, context->m_mouseButtonMiddle);
}
 
 
 
static void sSendKeyboardCallback(uSynergyContext *context, uint16_t key, uint16_t modifiers, uSynergyBool down, uSynergyBool repeat)
{
        // Skip if no callback is installed
        if (context->m_keyboardCallback == 0L)
                return;
 
        // Send callback
        context->m_keyboardCallback(context->m_cookie, key, modifiers, down, repeat);
}
 
 
 
static void sSendJoystickCallback(uSynergyContext *context, uint8_t joyNum)
{
        int8_t *sticks;
 
        // Skip if no callback is installed
        if (context->m_joystickCallback == 0L)
                return;
 
        // Send callback
        sticks = context->m_joystickSticks[joyNum];
        context->m_joystickCallback(context->m_cookie, joyNum, context->m_joystickButtons[joyNum], sticks[0], sticks[1], sticks[2], sticks[3]);
}
 
 
 
#define USYNERGY_IS_PACKET(pkt_id)      memcmp(message+4, pkt_id, 4)==0
static void sProcessMessage(uSynergyContext *context, const uint8_t *message)
{
        // We have a packet!
        if (memcmp(message+4, "Synergy", 7)==0)
        {
                // Welcome message
                //              kMsgHello                       = "Synergy%2i%2i"
                //              kMsgHelloBack           = "Synergy%2i%2i%s"
                sAddString(context, "Synergy");
                sAddUInt16(context, USYNERGY_PROTOCOL_MAJOR);
                sAddUInt16(context, USYNERGY_PROTOCOL_MINOR);
                sAddUInt32(context, (uint32_t)strlen(context->m_clientName));
                sAddString(context, context->m_clientName);
                if (!sSendReply(context))
                {
                        // Send reply failed, let's try to reconnect
                        sTrace(context, "SendReply failed, trying to reconnect in a second");
                        context->m_connected = USYNERGY_FALSE;
                        context->m_sleepFunc(context->m_cookie, 1000);
                }
                else
                {
                        // Let's assume we're connected
                        char buffer[256+1];
                        sprintf(buffer, "Connected as client \"%s\"", context->m_clientName);
                        sTrace(context, buffer);
                        context->m_hasReceivedHello = USYNERGY_TRUE;
                }
                return;
        }
        else if (USYNERGY_IS_PACKET("QINF"))
        {
                // Screen info. Reply with DINF
                //              kMsgQInfo                       = "QINF"
                //              kMsgDInfo                       = "DINF%2i%2i%2i%2i%2i%2i%2i"
                uint16_t x = 0, y = 0, warp = 0;
                sAddString(context, "DINF");
                sAddUInt16(context, x);
                sAddUInt16(context, y);
                sAddUInt16(context, context->m_clientWidth);
                sAddUInt16(context, context->m_clientHeight);
                sAddUInt16(context, warp);
                sAddUInt16(context, 0);         // mx?
                sAddUInt16(context, 0);         // my?
                sSendReply(context);
                return;
        }
        else if (USYNERGY_IS_PACKET("CIAK"))
        {
                // Do nothing?
                //              kMsgCInfoAck            = "CIAK"
                return;
        }
        else if (USYNERGY_IS_PACKET("CROP"))
        {
                // Do nothing?
                //              kMsgCResetOptions       = "CROP"
                return;
        }
        else if (USYNERGY_IS_PACKET("CINN"))
        {
                // Screen enter. Reply with CNOP
                //              kMsgCEnter                      = "CINN%2i%2i%4i%2i"
 
                // Obtain the Synergy sequence number
                context->m_sequenceNumber = sNetToNative32(message + 12);
                context->m_isCaptured = USYNERGY_TRUE;
 
                // Call callback
                if (context->m_screenActiveCallback != 0L)
                        context->m_screenActiveCallback(context->m_cookie, USYNERGY_TRUE);
        }
        else if (USYNERGY_IS_PACKET("COUT"))
        {
                // Screen leave
                //              kMsgCLeave                      = "COUT"
                context->m_isCaptured = USYNERGY_FALSE;
 
                // Call callback
                if (context->m_screenActiveCallback != 0L)
                        context->m_screenActiveCallback(context->m_cookie, USYNERGY_FALSE);
        }
        else if (USYNERGY_IS_PACKET("DMDN"))
        {
                // Mouse down
                //              kMsgDMouseDown          = "DMDN%1i"
                char btn = message[8]-1;
                if (btn==2)
                        context->m_mouseButtonRight             = USYNERGY_TRUE;
                else if (btn==1)
                        context->m_mouseButtonMiddle    = USYNERGY_TRUE;
                else
                        context->m_mouseButtonLeft              = USYNERGY_TRUE;
                sSendMouseCallback(context);
        }
        else if (USYNERGY_IS_PACKET("DMUP"))
        {
                // Mouse up
                //              kMsgDMouseUp            = "DMUP%1i"
                char btn = message[8]-1;
                if (btn==2)
                        context->m_mouseButtonRight             = USYNERGY_FALSE;
                else if (btn==1)
                        context->m_mouseButtonMiddle    = USYNERGY_FALSE;
                else
                        context->m_mouseButtonLeft              = USYNERGY_FALSE;
                sSendMouseCallback(context);
        }
        else if (USYNERGY_IS_PACKET("DMMV"))
        {
                // Mouse move. Reply with CNOP
                //              kMsgDMouseMove          = "DMMV%2i%2i"
                context->m_mouseX = sNetToNative16(message+8);
                context->m_mouseY = sNetToNative16(message+10);
                sSendMouseCallback(context);
        }
        else if (USYNERGY_IS_PACKET("DMWM"))
        {
                // Mouse wheel
                //              kMsgDMouseWheel         = "DMWM%2i%2i"
                //              kMsgDMouseWheel1_0      = "DMWM%2i"
                context->m_mouseWheelX += sNetToNative16(message+8);
                context->m_mouseWheelY += sNetToNative16(message+10);
                sSendMouseCallback(context);
        }
        else if (USYNERGY_IS_PACKET("DKDN"))
        {
                // Key down
                //              kMsgDKeyDown            = "DKDN%2i%2i%2i"
                //              kMsgDKeyDown1_0         = "DKDN%2i%2i"
                //uint16_t id = sNetToNative16(message+8);
                uint16_t mod = sNetToNative16(message+10);
                uint16_t key = sNetToNative16(message+12);
                sSendKeyboardCallback(context, key, mod, USYNERGY_TRUE, USYNERGY_FALSE);
        }
        else if (USYNERGY_IS_PACKET("DKRP"))
        {
                // Key repeat
                //              kMsgDKeyRepeat          = "DKRP%2i%2i%2i%2i"
                //              kMsgDKeyRepeat1_0       = "DKRP%2i%2i%2i"
                uint16_t mod = sNetToNative16(message+10);
//              uint16_t count = sNetToNative16(message+12);
                uint16_t key = sNetToNative16(message+14);
                sSendKeyboardCallback(context, key, mod, USYNERGY_TRUE, USYNERGY_TRUE);
        }
        else if (USYNERGY_IS_PACKET("DKUP"))
        {
                // Key up
                //              kMsgDKeyUp                      = "DKUP%2i%2i%2i"
                //              kMsgDKeyUp1_0           = "DKUP%2i%2i"
                //uint16 id=Endian::sNetToNative(sbuf[4]);
                uint16_t mod = sNetToNative16(message+10);
                uint16_t key = sNetToNative16(message+12);
                sSendKeyboardCallback(context, key, mod, USYNERGY_FALSE, USYNERGY_FALSE);
        }
        else if (USYNERGY_IS_PACKET("DGBT"))
        {
                // Joystick buttons
                //              kMsgDGameButtons        = "DGBT%1i%2i";
                uint8_t joy_num = message[8];
                if (joy_num<USYNERGY_NUM_JOYSTICKS)
                {
                        // Copy button state, then send callback
                        context->m_joystickButtons[joy_num] = (message[9] << 8) | message[10];
                        sSendJoystickCallback(context, joy_num);
                }
        }
        else if (USYNERGY_IS_PACKET("DGST"))
        {
                // Joystick sticks
                //              kMsgDGameSticks         = "DGST%1i%1i%1i%1i%1i";
                uint8_t joy_num = message[8];
                if (joy_num<USYNERGY_NUM_JOYSTICKS)
                {
                        // Copy stick state, then send callback
                        memcpy(context->m_joystickSticks[joy_num], message+9, 4);
                        sSendJoystickCallback(context, joy_num);
                }
        }
        else if (USYNERGY_IS_PACKET("DSOP"))
        {
                // Set options
                //              kMsgDSetOptions         = "DSOP%4I"
        }
        else if (USYNERGY_IS_PACKET("CALV"))
        {
                // Keepalive, reply with CALV and then CNOP
                //              kMsgCKeepAlive          = "CALV"
                sAddString(context, "CALV");
                sSendReply(context);
                // now reply with CNOP
        }
        else if (USYNERGY_IS_PACKET("DCLP"))
        {
                // Clipboard message
                //              kMsgDClipboard          = "DCLP%1i%4i%s"
                //
                // The clipboard message contains:
                //              1 uint32:       The size of the message
                //              4 chars:        The identifier ("DCLP")
                //              1 uint8:        The clipboard index
                //              1 uint32:       The sequence number. It's zero, because this message is always coming from the server?
                //              1 uint32:       The total size of the remaining 'string' (as per the Synergy %s string format (which is 1 uint32 for size followed by a char buffer (not necessarily null terminated)).
                //              1 uint32:       The number of formats present in the message
                // And then 'number of formats' times the following:
                //              1 uint32:       The format of the clipboard data
                //              1 uint32:       The size n of the clipboard data
                //              n uint8:        The clipboard data
                const uint8_t * parse_msg       = message+17;
                uint32_t                num_formats = sNetToNative32(parse_msg);
                parse_msg += 4;
                for (; num_formats; num_formats--)
                {
                        // Parse clipboard format header
                        uint32_t format = sNetToNative32(parse_msg);
                        uint32_t size   = sNetToNative32(parse_msg+4);
                        parse_msg += 8;
                        
                        // Call callback
                        if (context->m_clipboardCallback)
                                context->m_clipboardCallback(context->m_cookie, format, parse_msg, size);
 
                        parse_msg += size;
                }
        }
        else
        {
                // Unknown packet, could be any of these
                //              kMsgCNoop                       = "CNOP"
                //              kMsgCClose                      = "CBYE"
                //              kMsgCClipboard          = "CCLP%1i%4i"
                //              kMsgCScreenSaver        = "CSEC%1i"
                //              kMsgDKeyRepeat          = "DKRP%2i%2i%2i%2i"
                //              kMsgDKeyRepeat1_0       = "DKRP%2i%2i%2i"
                //              kMsgDMouseRelMove       = "DMRM%2i%2i"
                //              kMsgEIncompatible       = "EICV%2i%2i"
                //              kMsgEBusy                       = "EBSY"
                //              kMsgEUnknown            = "EUNK"
                //              kMsgEBad                        = "EBAD"
                char buffer[64];
                sprintf(buffer, "Unknown packet '%c%c%c%c'", message[4], message[5], message[6], message[7]);
                sTrace(context, buffer);
                return;
        }
 
        // Reply with CNOP maybe?
        sAddString(context, "CNOP");
        sSendReply(context);
}
#undef USYNERGY_IS_PACKET
 
 
 
static void sSetDisconnected(uSynergyContext *context)
{
        context->m_connected            = USYNERGY_FALSE;
        context->m_hasReceivedHello = USYNERGY_FALSE;
        context->m_isCaptured           = USYNERGY_FALSE;
        context->m_replyCur                     = context->m_replyBuffer + 4;
        context->m_sequenceNumber       = 0;
}
 
 
 
static void sUpdateContext(uSynergyContext *context)
{
        /* Receive data (blocking) */
        int receive_size = USYNERGY_RECEIVE_BUFFER_SIZE - context->m_receiveOfs;
        int num_received = 0;
        int packlen = 0;
        if (context->m_receiveFunc(context->m_cookie, context->m_receiveBuffer + context->m_receiveOfs, receive_size, &num_received) == USYNERGY_FALSE)
        {
                /* Receive failed, let's try to reconnect */
                char buffer[128];
                sprintf(buffer, "Receive failed (%d bytes asked, %d bytes received), trying to reconnect in a second", receive_size, num_received);
                sTrace(context, buffer);
                sSetDisconnected(context);
                context->m_sleepFunc(context->m_cookie, 1000);
                return;
        }
        context->m_receiveOfs += num_received;
 
        /*      If we didn't receive any data then we're probably still polling to get connected and
                therefore not getting any data back. To avoid overloading the system with a Synergy
                thread that would hammer on polling, we let it rest for a bit if there's no data. */
        if (num_received == 0)
                context->m_sleepFunc(context->m_cookie, 500);
 
        /* Check for timeouts */
        if (context->m_hasReceivedHello)
        {
                uint32_t cur_time = context->m_getTimeFunc();
                if (num_received == 0)
                {
                        /* Timeout after 2 secs of inactivity (we received no CALV) */
                        if ((cur_time - context->m_lastMessageTime) > USYNERGY_IDLE_TIMEOUT)
                                sSetDisconnected(context);
                }
                else
                        context->m_lastMessageTime = cur_time;
        }
 
        /* Eat packets */
        for (;;)
        {
                /* Grab packet length and bail out if the packet goes beyond the end of the buffer */
                packlen = sNetToNative32(context->m_receiveBuffer);
                if (packlen+4 > context->m_receiveOfs)
                        break;
 
                /* Process message */
                sProcessMessage(context, context->m_receiveBuffer);
 
                /* Move packet to front of buffer */
                memmove(context->m_receiveBuffer, context->m_receiveBuffer+packlen+4, context->m_receiveOfs-packlen-4);
                context->m_receiveOfs -= packlen+4;
        }
 
        /* Throw away over-sized packets */
        if (packlen > USYNERGY_RECEIVE_BUFFER_SIZE)
        {
                /* Oversized packet, ditch tail end */
                char buffer[128];
                sprintf(buffer, "Oversized packet: '%c%c%c%c' (length %d)", context->m_receiveBuffer[4], context->m_receiveBuffer[5], context->m_receiveBuffer[6], context->m_receiveBuffer[7], packlen);
                sTrace(context, buffer);
                num_received = context->m_receiveOfs-4; // 4 bytes for the size field
                while (num_received != packlen)
                {
                        int buffer_left = packlen - num_received;
                        int to_receive = buffer_left < USYNERGY_RECEIVE_BUFFER_SIZE ? buffer_left : USYNERGY_RECEIVE_BUFFER_SIZE;
                        int ditch_received = 0;
                        if (context->m_receiveFunc(context->m_cookie, context->m_receiveBuffer, to_receive, &ditch_received) == USYNERGY_FALSE)
                        {
                                /* Receive failed, let's try to reconnect */
                                sTrace(context, "Receive failed, trying to reconnect in a second");
                                sSetDisconnected(context);
                                context->m_sleepFunc(context->m_cookie, 1000);
                                break;
                        }
                        else
                        {
                                num_received += ditch_received;
                        }
                }
                context->m_receiveOfs = 0;
        }
}
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Public interface
//---------------------------------------------------------------------------------------------------------------------
 
 
 
void uSynergyInit(uSynergyContext *context)
{
        /* Zero memory */
        memset(context, 0, sizeof(uSynergyContext));
 
        /* Initialize to default state */
        sSetDisconnected(context);
}
 
 
void uSynergyUpdate(uSynergyContext *context)
{
        if (context->m_connected)
        {
                /* Update context, receive data, call callbacks */
                sUpdateContext(context);
        }
        else
        {
                /* Try to connect */
                if (context->m_connectFunc(context->m_cookie))
                        context->m_connected = USYNERGY_TRUE;
        }
}
 
 
 
void uSynergySendClipboard(uSynergyContext *context, const char *text)
{
        // Calculate maximum size that will fit in a reply packet
        uint32_t overhead_size =        4 +                                     /* Message size */
                                                                4 +                                     /* Message ID */
                                                                1 +                                     /* Clipboard index */
                                                                4 +                                     /* Sequence number */
                                                                4 +                                     /* Rest of message size (because it's a Synergy string from here on) */
                                                                4 +                                     /* Number of clipboard formats */
                                                                4 +                                     /* Clipboard format */
                                                                4;                                      /* Clipboard data length */
        uint32_t max_length = USYNERGY_REPLY_BUFFER_SIZE - overhead_size;
        
        // Clip text to max length
        uint32_t text_length = (uint32_t)strlen(text);
        if (text_length > max_length)
        {
                char buffer[128];
                sprintf(buffer, "Clipboard buffer too small, clipboard truncated at %d characters", max_length);
                sTrace(context, buffer);
                text_length = max_length;
        }
 
        // Assemble packet
        sAddString(context, "DCLP");
        sAddUInt8(context, 0);                                                  /* Clipboard index */
        sAddUInt32(context, context->m_sequenceNumber);
        sAddUInt32(context, 4+4+4+text_length);                 /* Rest of message size: numFormats, format, length, data */
        sAddUInt32(context, 1);                                                 /* Number of formats (only text for now) */
        sAddUInt32(context, USYNERGY_CLIPBOARD_FORMAT_TEXT);
        sAddUInt32(context, text_length);
        sAddString(context, text);
        sSendReply(context);
}