libvncserver/rfb/rfbclient.h

Go to the documentation of this file.

#ifndef RFBCLIENT_H
#define RFBCLIENT_H

/*
 *  Copyright (C) 2000, 2001 Const Kaplinsky.  All Rights Reserved.
 *  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
 *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
 *
 *  This is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This software is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this software; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
 *  USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include "rfbproto.h"
#include "keysym.h"
#ifdef LIBVNCSERVER_WITH_CLIENT_TLS
#include <gnutls/gnutls.h>
#endif

#define rfbClientSwap16IfLE(s) \
    (*(char *)&client->endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s))

#define rfbClientSwap32IfLE(l) \
    (*(char *)&client->endianTest ? ((((l) & 0xff000000) >> 24) | \
                 (((l) & 0x00ff0000) >> 8)  | \
                 (((l) & 0x0000ff00) << 8)  | \
                 (((l) & 0x000000ff) << 24))  : (l))

#define rfbClientSwap64IfLE(l) \
    (*(char *)&client->endianTest ? ((((l) & 0xff00000000000000ULL) >> 56) | \
                 (((l) & 0x00ff000000000000ULL) >> 40)  | \
                 (((l) & 0x0000ff0000000000ULL) >> 24)  | \
                 (((l) & 0x000000ff00000000ULL) >> 8)  | \
                 (((l) & 0x00000000ff000000ULL) << 8)  | \
                 (((l) & 0x0000000000ff0000ULL) << 24)  | \
                 (((l) & 0x000000000000ff00ULL) << 40)  | \
                 (((l) & 0x00000000000000ffULL) << 56))  : (l))

#define FLASH_PORT_OFFSET 5400
#define LISTEN_PORT_OFFSET 5500
#define TUNNEL_PORT_OFFSET 5500
#define SERVER_PORT_OFFSET 5900

#define DEFAULT_SSH_CMD "/usr/bin/ssh"
#define DEFAULT_TUNNEL_CMD  \
  (DEFAULT_SSH_CMD " -f -L %L:localhost:%R %H sleep 20")
#define DEFAULT_VIA_CMD     \
  (DEFAULT_SSH_CMD " -f -L %L:%H:%R %G sleep 20")

#if(defined __cplusplus)
extern "C"
{
#endif

typedef struct {
  FILE* file;
  struct timeval tv;
  rfbBool readTimestamp;
  rfbBool doNotSleep;
} rfbVNCRec;

typedef struct rfbClientData {
    void* tag;
    void* data;
    struct rfbClientData* next;
} rfbClientData;

typedef struct {
  rfbBool shareDesktop;
  rfbBool viewOnly;

  const char* encodingsString;

  rfbBool useBGR233;
  int nColours;
  rfbBool forceOwnCmap;
  rfbBool forceTrueColour;
  int requestedDepth;

  int compressLevel;
  int qualityLevel;
  rfbBool enableJPEG;
  rfbBool useRemoteCursor;
  rfbBool palmVNC;  
  int scaleSetting; 
} AppData;

typedef union _rfbCredential
{
  struct
  {
    char *x509CACertFile;
    char *x509CACrlFile;
    char *x509ClientCertFile;
    char *x509ClientKeyFile;
  } x509Credential;
  struct
  {
    char *username;
    char *password;
  } userCredential;
} rfbCredential;

#define rfbCredentialTypeX509 1
#define rfbCredentialTypeUser 2

struct _rfbClient;

typedef void (*HandleTextChatProc)(struct _rfbClient* client, int value, char *text);
typedef void (*HandleXvpMsgProc)(struct _rfbClient* client, uint8_t version, uint8_t opcode);
typedef void (*HandleKeyboardLedStateProc)(struct _rfbClient* client, int value, int pad);
typedef rfbBool (*HandleCursorPosProc)(struct _rfbClient* client, int x, int y);
typedef void (*SoftCursorLockAreaProc)(struct _rfbClient* client, int x, int y, int w, int h);
typedef void (*SoftCursorUnlockScreenProc)(struct _rfbClient* client);
typedef void (*GotFrameBufferUpdateProc)(struct _rfbClient* client, int x, int y, int w, int h);
typedef void (*FinishedFrameBufferUpdateProc)(struct _rfbClient* client);
typedef char* (*GetPasswordProc)(struct _rfbClient* client);
typedef rfbCredential* (*GetCredentialProc)(struct _rfbClient* client, int credentialType);
typedef rfbBool (*MallocFrameBufferProc)(struct _rfbClient* client);
typedef void (*GotXCutTextProc)(struct _rfbClient* client, const char *text, int textlen);
typedef void (*BellProc)(struct _rfbClient* client);

typedef void (*GotCursorShapeProc)(struct _rfbClient* client, int xhot, int yhot, int width, int height, int bytesPerPixel);
typedef void (*GotCopyRectProc)(struct _rfbClient* client, int src_x, int src_y, int w, int h, int dest_x, int dest_y);

typedef struct _rfbClient {
    uint8_t* frameBuffer;
    int width, height;

    int endianTest;

    AppData appData;

    const char* programName;
    char* serverHost;
    int serverPort; 
    rfbBool listenSpecified;
    int listenPort, flashPort;

    struct {
        int x, y, w, h;
    } updateRect;

#define RFB_BUFFER_SIZE (640*480)
    char buffer[RFB_BUFFER_SIZE];

    /* rfbproto.c */

    int sock;
    rfbBool canUseCoRRE;
    rfbBool canUseHextile;
    char *desktopName;
    rfbPixelFormat format;
    rfbServerInitMsg si;

    /* listen.c */
        int listenSock;

    /* sockets.c */
#define RFB_BUF_SIZE 8192
    char buf[RFB_BUF_SIZE];
    char *bufoutptr;
    int buffered;

    /* The zlib encoding requires expansion/decompression/deflation of the
       compressed data in the "buffer" above into another, result buffer.
       However, the size of the result buffer can be determined precisely
       based on the bitsPerPixel, height and width of the rectangle.  We
       allocate this buffer one time to be the full size of the buffer. */

    /* Ultra Encoding uses this buffer too */
    
    int ultra_buffer_size;
    char *ultra_buffer;

    int raw_buffer_size;
    char *raw_buffer;

#ifdef LIBVNCSERVER_HAVE_LIBZ
    z_stream decompStream;
    rfbBool decompStreamInited;
#endif


#ifdef LIBVNCSERVER_HAVE_LIBZ
    /*
     * Variables for the ``tight'' encoding implementation.
     */

#define ZLIB_BUFFER_SIZE 30000
    char zlib_buffer[ZLIB_BUFFER_SIZE];

    /* Four independent compression streams for zlib library. */
    z_stream zlibStream[4];
    rfbBool zlibStreamActive[4];

    /* Filter stuff. Should be initialized by filter initialization code. */
    rfbBool cutZeros;
    int rectWidth, rectColors;
    char tightPalette[256*4];
    uint8_t tightPrevRow[2048*3*sizeof(uint16_t)];

#ifdef LIBVNCSERVER_HAVE_LIBJPEG

    rfbBool jpegError;

    struct jpeg_source_mgr* jpegSrcManager;
    void* jpegBufferPtr;
    size_t jpegBufferLen;

#endif
#endif


    /* cursor.c */
    uint8_t *rcSource, *rcMask;

    rfbClientData* clientData;

    rfbVNCRec* vncRec;

    /* Keyboard State support (is 'Caps Lock' set on the remote display???) */
    int KeyboardLedStateEnabled;
    int CurrentKeyboardLedState;

    int canHandleNewFBSize;

    /* hooks */
    HandleTextChatProc         HandleTextChat;
    HandleKeyboardLedStateProc HandleKeyboardLedState;
    HandleCursorPosProc HandleCursorPos;
    SoftCursorLockAreaProc SoftCursorLockArea;
    SoftCursorUnlockScreenProc SoftCursorUnlockScreen;
    GotFrameBufferUpdateProc GotFrameBufferUpdate;
    FinishedFrameBufferUpdateProc FinishedFrameBufferUpdate;
    GetPasswordProc GetPassword;
    MallocFrameBufferProc MallocFrameBuffer;
    GotXCutTextProc GotXCutText;
    BellProc Bell;

    GotCursorShapeProc GotCursorShape;
    GotCopyRectProc GotCopyRect;

    rfbSupportedMessages supportedMessages;

    int major, minor;

    uint32_t authScheme, subAuthScheme;

#ifdef LIBVNCSERVER_WITH_CLIENT_TLS

    gnutls_session_t tlsSession;
#endif

    GetCredentialProc GetCredential;

    uint32_t *clientAuthSchemes;

    char *destHost;
    int destPort;

        int QoS_DSCP;

    HandleXvpMsgProc           HandleXvpMsg;
} rfbClient;

/* cursor.c */

extern rfbBool HandleCursorShape(rfbClient* client,int xhot, int yhot, int width, int height, uint32_t enc);

/* listen.c */

extern void listenForIncomingConnections(rfbClient* viewer);
extern int listenForIncomingConnectionsNoFork(rfbClient* viewer, int usec_timeout);

/* rfbproto.c */

extern rfbBool rfbEnableClientLogging;
typedef void (*rfbClientLogProc)(const char *format, ...);
extern rfbClientLogProc rfbClientLog,rfbClientErr;
extern rfbBool ConnectToRFBServer(rfbClient* client,const char *hostname, int port);
extern rfbBool ConnectToRFBRepeater(rfbClient* client,const char *repeaterHost, int repeaterPort, const char *destHost, int destPort);
extern void SetClientAuthSchemes(rfbClient* client,const uint32_t *authSchemes, int size);
extern rfbBool InitialiseRFBConnection(rfbClient* client);
extern rfbBool SetFormatAndEncodings(rfbClient* client);
extern rfbBool SendIncrementalFramebufferUpdateRequest(rfbClient* client);
extern rfbBool SendFramebufferUpdateRequest(rfbClient* client,
                     int x, int y, int w, int h,
                     rfbBool incremental);
extern rfbBool SendScaleSetting(rfbClient* client,int scaleSetting);
extern rfbBool SendPointerEvent(rfbClient* client,int x, int y, int buttonMask);
extern rfbBool SendKeyEvent(rfbClient* client,uint32_t key, rfbBool down);
extern rfbBool SendClientCutText(rfbClient* client,char *str, int len);
extern rfbBool HandleRFBServerMessage(rfbClient* client);

extern rfbBool TextChatSend(rfbClient* client, char *text);
extern rfbBool TextChatOpen(rfbClient* client);
extern rfbBool TextChatClose(rfbClient* client);
extern rfbBool TextChatFinish(rfbClient* client);
extern rfbBool PermitServerInput(rfbClient* client, int enabled);
extern rfbBool SendXvpMsg(rfbClient* client, uint8_t version, uint8_t code);

extern void PrintPixelFormat(rfbPixelFormat *format);

extern rfbBool SupportsClient2Server(rfbClient* client, int messageType);
extern rfbBool SupportsServer2Client(rfbClient* client, int messageType);

/* client data */

void rfbClientSetClientData(rfbClient* client, void* tag, void* data);
void* rfbClientGetClientData(rfbClient* client, void* tag);

/* protocol extensions */

typedef struct _rfbClientProtocolExtension {
    int* encodings;
    rfbBool (*handleEncoding)(rfbClient* cl,
        rfbFramebufferUpdateRectHeader* rect);
    rfbBool (*handleMessage)(rfbClient* cl,
         rfbServerToClientMsg* message);
    struct _rfbClientProtocolExtension* next;
} rfbClientProtocolExtension;

void rfbClientRegisterExtension(rfbClientProtocolExtension* e);

/* sockets.c */

extern rfbBool errorMessageOnReadFailure;

extern rfbBool ReadFromRFBServer(rfbClient* client, char *out, unsigned int n);
extern rfbBool WriteToRFBServer(rfbClient* client, char *buf, int n);
extern int FindFreeTcpPort(void);
extern int ListenAtTcpPort(int port);
extern int ConnectClientToTcpAddr(unsigned int host, int port);
extern int ConnectClientToTcpAddr6(const char *hostname, int port);
extern int ConnectClientToUnixSock(const char *sockFile);
extern int AcceptTcpConnection(int listenSock);
extern rfbBool SetNonBlocking(int sock);
extern rfbBool SetDSCP(int sock, int dscp);

extern rfbBool StringToIPAddr(const char *str, unsigned int *addr);
extern rfbBool SameMachine(int sock);
extern int WaitForMessage(rfbClient* client,unsigned int usecs);

/* vncviewer.c */
rfbClient* rfbGetClient(int bitsPerSample,int samplesPerPixel,int bytesPerPixel);
rfbBool rfbInitClient(rfbClient* client,int* argc,char** argv);
void rfbClientCleanup(rfbClient* client);

#if(defined __cplusplus)
}
#endif

#endif