Annotation of qemu/vnc.h, revision 1.1.1.3

1.1.1.2   root        1: /*
                      2:  * QEMU VNC display driver
                      3:  *
                      4:  * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
                      5:  * Copyright (C) 2006 Fabrice Bellard
                      6:  * Copyright (C) 2009 Red Hat, Inc
                      7:  *
                      8:  * Permission is hereby granted, free of charge, to any person obtaining a copy
                      9:  * of this software and associated documentation files (the "Software"), to deal
                     10:  * in the Software without restriction, including without limitation the rights
                     11:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                     12:  * copies of the Software, and to permit persons to whom the Software is
                     13:  * furnished to do so, subject to the following conditions:
                     14:  *
                     15:  * The above copyright notice and this permission notice shall be included in
                     16:  * all copies or substantial portions of the Software.
                     17:  *
                     18:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                     19:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                     20:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
                     21:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                     22:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                     23:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
                     24:  * THE SOFTWARE.
                     25:  */
                     26: 
                     27: #ifndef __QEMU_VNC_H
                     28: #define __QEMU_VNC_H
                     29: 
                     30: #include "qemu-common.h"
                     31: #include "console.h"
                     32: #include "monitor.h"
                     33: #include "audio/audio.h"
                     34: #include <zlib.h>
                     35: 
                     36: #include "keymaps.h"
                     37: 
                     38: // #define _VNC_DEBUG 1
                     39: 
                     40: #ifdef _VNC_DEBUG
                     41: #define VNC_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
                     42: #else
                     43: #define VNC_DEBUG(fmt, ...) do { } while (0)
                     44: #endif
                     45: 
                     46: /*****************************************************************************
                     47:  *
                     48:  * Core data structures
                     49:  *
                     50:  *****************************************************************************/
                     51: 
                     52: typedef struct Buffer
                     53: {
                     54:     size_t capacity;
                     55:     size_t offset;
                     56:     uint8_t *buffer;
                     57: } Buffer;
                     58: 
                     59: typedef struct VncState VncState;
                     60: 
                     61: typedef int VncReadEvent(VncState *vs, uint8_t *data, size_t len);
                     62: 
                     63: typedef void VncWritePixels(VncState *vs, void *data, int size);
                     64: 
                     65: typedef void VncSendHextileTile(VncState *vs,
                     66:                                 int x, int y, int w, int h,
                     67:                                 void *last_bg,
                     68:                                 void *last_fg,
                     69:                                 int *has_bg, int *has_fg);
                     70: 
                     71: #define VNC_MAX_WIDTH 2048
                     72: #define VNC_MAX_HEIGHT 2048
                     73: #define VNC_DIRTY_WORDS (VNC_MAX_WIDTH / (16 * 32))
                     74: 
                     75: #define VNC_AUTH_CHALLENGE_SIZE 16
                     76: 
                     77: typedef struct VncDisplay VncDisplay;
                     78: 
                     79: #ifdef CONFIG_VNC_TLS
                     80: #include "vnc-tls.h"
                     81: #include "vnc-auth-vencrypt.h"
                     82: #endif
                     83: #ifdef CONFIG_VNC_SASL
                     84: #include "vnc-auth-sasl.h"
                     85: #endif
                     86: 
1.1.1.3 ! root       87: struct VncSurface
        !            88: {
        !            89:     uint32_t dirty[VNC_MAX_HEIGHT][VNC_DIRTY_WORDS];
        !            90:     DisplaySurface *ds;
        !            91: };
1.1.1.2   root       92: 
                     93: struct VncDisplay
                     94: {
1.1.1.3 ! root       95:     QEMUTimer *timer;
        !            96:     int timer_interval;
1.1.1.2   root       97:     int lsock;
                     98:     DisplayState *ds;
                     99:     VncState *clients;
                    100:     kbd_layout_t *kbd_layout;
                    101: 
1.1.1.3 ! root      102:     struct VncSurface guest;   /* guest visible surface (aka ds->surface) */
        !           103:     DisplaySurface *server;  /* vnc server surface */
        !           104: 
1.1.1.2   root      105:     char *display;
                    106:     char *password;
                    107:     int auth;
                    108: #ifdef CONFIG_VNC_TLS
                    109:     int subauth; /* Used by VeNCrypt */
                    110:     VncDisplayTLS tls;
                    111: #endif
                    112: #ifdef CONFIG_VNC_SASL
                    113:     VncDisplaySASL sasl;
                    114: #endif
                    115: };
                    116: 
                    117: struct VncState
                    118: {
                    119:     int csock;
                    120: 
                    121:     DisplayState *ds;
1.1.1.3 ! root      122:     uint32_t dirty[VNC_MAX_HEIGHT][VNC_DIRTY_WORDS];
1.1.1.2   root      123: 
                    124:     VncDisplay *vd;
                    125:     int need_update;
                    126:     int force_update;
                    127:     uint32_t features;
                    128:     int absolute;
                    129:     int last_x;
                    130:     int last_y;
                    131: 
                    132:     uint32_t vnc_encoding;
                    133:     uint8_t tight_quality;
                    134:     uint8_t tight_compression;
                    135: 
                    136:     int major;
                    137:     int minor;
                    138: 
                    139:     char challenge[VNC_AUTH_CHALLENGE_SIZE];
                    140: #ifdef CONFIG_VNC_TLS
                    141:     VncStateTLS tls;
                    142: #endif
                    143: #ifdef CONFIG_VNC_SASL
                    144:     VncStateSASL sasl;
                    145: #endif
                    146: 
                    147:     Buffer output;
                    148:     Buffer input;
                    149:     /* current output mode information */
                    150:     VncWritePixels *write_pixels;
                    151:     VncSendHextileTile *send_hextile_tile;
                    152:     DisplaySurface clientds;
                    153: 
                    154:     CaptureVoiceOut *audio_cap;
                    155:     struct audsettings as;
                    156: 
                    157:     VncReadEvent *read_handler;
                    158:     size_t read_handler_expect;
                    159:     /* input */
                    160:     uint8_t modifiers_state[256];
                    161: 
                    162:     Buffer zlib;
                    163:     Buffer zlib_tmp;
                    164:     z_stream zlib_stream[4];
                    165: 
                    166:     VncState *next;
                    167: };
                    168: 
1.1       root      169: 
                    170: /*****************************************************************************
                    171:  *
                    172:  * Authentication modes
                    173:  *
                    174:  *****************************************************************************/
                    175: 
                    176: enum {
                    177:     VNC_AUTH_INVALID = 0,
                    178:     VNC_AUTH_NONE = 1,
                    179:     VNC_AUTH_VNC = 2,
                    180:     VNC_AUTH_RA2 = 5,
                    181:     VNC_AUTH_RA2NE = 6,
                    182:     VNC_AUTH_TIGHT = 16,
                    183:     VNC_AUTH_ULTRA = 17,
1.1.1.2   root      184:     VNC_AUTH_TLS = 18,      /* Supported in GTK-VNC & VINO */
                    185:     VNC_AUTH_VENCRYPT = 19, /* Supported in GTK-VNC & VeNCrypt */
                    186:     VNC_AUTH_SASL = 20,     /* Supported in GTK-VNC & VINO */
1.1       root      187: };
                    188: 
                    189: enum {
                    190:     VNC_AUTH_VENCRYPT_PLAIN = 256,
                    191:     VNC_AUTH_VENCRYPT_TLSNONE = 257,
                    192:     VNC_AUTH_VENCRYPT_TLSVNC = 258,
                    193:     VNC_AUTH_VENCRYPT_TLSPLAIN = 259,
                    194:     VNC_AUTH_VENCRYPT_X509NONE = 260,
                    195:     VNC_AUTH_VENCRYPT_X509VNC = 261,
                    196:     VNC_AUTH_VENCRYPT_X509PLAIN = 262,
1.1.1.2   root      197:     VNC_AUTH_VENCRYPT_X509SASL = 263,
                    198:     VNC_AUTH_VENCRYPT_TLSSASL = 264,
1.1       root      199: };
                    200: 
                    201: 
                    202: /*****************************************************************************
                    203:  *
                    204:  * Encoding types
                    205:  *
                    206:  *****************************************************************************/
                    207: 
                    208: #define VNC_ENCODING_RAW                  0x00000000
                    209: #define VNC_ENCODING_COPYRECT             0x00000001
                    210: #define VNC_ENCODING_RRE                  0x00000002
                    211: #define VNC_ENCODING_CORRE                0x00000004
                    212: #define VNC_ENCODING_HEXTILE              0x00000005
                    213: #define VNC_ENCODING_ZLIB                 0x00000006
                    214: #define VNC_ENCODING_TIGHT                0x00000007
                    215: #define VNC_ENCODING_ZLIBHEX              0x00000008
                    216: #define VNC_ENCODING_TRLE                 0x0000000f
                    217: #define VNC_ENCODING_ZRLE                 0x00000010
                    218: #define VNC_ENCODING_ZYWRLE               0x00000011
                    219: #define VNC_ENCODING_COMPRESSLEVEL0       0xFFFFFF00 /* -256 */
                    220: #define VNC_ENCODING_QUALITYLEVEL0        0xFFFFFFE0 /* -32  */
                    221: #define VNC_ENCODING_XCURSOR              0xFFFFFF10 /* -240 */
                    222: #define VNC_ENCODING_RICH_CURSOR          0xFFFFFF11 /* -239 */
                    223: #define VNC_ENCODING_POINTER_POS          0xFFFFFF18 /* -232 */
                    224: #define VNC_ENCODING_LASTRECT             0xFFFFFF20 /* -224 */
                    225: #define VNC_ENCODING_DESKTOPRESIZE        0xFFFFFF21 /* -223 */
                    226: #define VNC_ENCODING_POINTER_TYPE_CHANGE  0XFFFFFEFF /* -257 */
                    227: #define VNC_ENCODING_EXT_KEY_EVENT        0XFFFFFEFE /* -258 */
                    228: #define VNC_ENCODING_AUDIO                0XFFFFFEFD /* -259 */
                    229: #define VNC_ENCODING_WMVi                 0x574D5669
                    230: 
                    231: /*****************************************************************************
                    232:  *
                    233:  * Other tight constants
                    234:  *
                    235:  *****************************************************************************/
                    236: 
                    237: /*
                    238:  * Vendors known by TightVNC: standard VNC/RealVNC, TridiaVNC, and TightVNC.
                    239:  */
                    240: 
                    241: #define VNC_TIGHT_CCB_RESET_MASK   (0x0f)
                    242: #define VNC_TIGHT_CCB_TYPE_MASK    (0x0f << 4)
                    243: #define VNC_TIGHT_CCB_TYPE_FILL    (0x08 << 4)
                    244: #define VNC_TIGHT_CCB_TYPE_JPEG    (0x09 << 4)
                    245: #define VNC_TIGHT_CCB_BASIC_MAX    (0x07 << 4)
                    246: #define VNC_TIGHT_CCB_BASIC_ZLIB   (0x03 << 4)
                    247: #define VNC_TIGHT_CCB_BASIC_FILTER (0x04 << 4)
                    248: 
                    249: /*****************************************************************************
                    250:  *
                    251:  * Features
                    252:  *
                    253:  *****************************************************************************/
                    254: 
                    255: #define VNC_FEATURE_RESIZE                   0
                    256: #define VNC_FEATURE_HEXTILE                  1
                    257: #define VNC_FEATURE_POINTER_TYPE_CHANGE      2
                    258: #define VNC_FEATURE_WMVI                     3
                    259: #define VNC_FEATURE_TIGHT                    4
                    260: #define VNC_FEATURE_ZLIB                     5
                    261: #define VNC_FEATURE_COPYRECT                 6
                    262: 
                    263: #define VNC_FEATURE_RESIZE_MASK              (1 << VNC_FEATURE_RESIZE)
                    264: #define VNC_FEATURE_HEXTILE_MASK             (1 << VNC_FEATURE_HEXTILE)
                    265: #define VNC_FEATURE_POINTER_TYPE_CHANGE_MASK (1 << VNC_FEATURE_POINTER_TYPE_CHANGE)
                    266: #define VNC_FEATURE_WMVI_MASK                (1 << VNC_FEATURE_WMVI)
                    267: #define VNC_FEATURE_TIGHT_MASK               (1 << VNC_FEATURE_TIGHT)
                    268: #define VNC_FEATURE_ZLIB_MASK                (1 << VNC_FEATURE_ZLIB)
                    269: #define VNC_FEATURE_COPYRECT_MASK            (1 << VNC_FEATURE_COPYRECT)
                    270: 
1.1.1.2   root      271: 
                    272: /*****************************************************************************
                    273:  *
                    274:  * Internal APIs
                    275:  *
                    276:  *****************************************************************************/
                    277: 
                    278: /* Event loop functions */
                    279: void vnc_client_read(void *opaque);
                    280: void vnc_client_write(void *opaque);
                    281: 
                    282: long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen);
                    283: long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen);
                    284: 
                    285: /* Protocol I/O functions */
                    286: void vnc_write(VncState *vs, const void *data, size_t len);
                    287: void vnc_write_u32(VncState *vs, uint32_t value);
                    288: void vnc_write_s32(VncState *vs, int32_t value);
                    289: void vnc_write_u16(VncState *vs, uint16_t value);
                    290: void vnc_write_u8(VncState *vs, uint8_t value);
                    291: void vnc_flush(VncState *vs);
                    292: void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting);
                    293: 
                    294: 
                    295: /* Buffer I/O functions */
                    296: uint8_t read_u8(uint8_t *data, size_t offset);
                    297: uint16_t read_u16(uint8_t *data, size_t offset);
                    298: int32_t read_s32(uint8_t *data, size_t offset);
                    299: uint32_t read_u32(uint8_t *data, size_t offset);
                    300: 
                    301: /* Protocol stage functions */
                    302: void vnc_client_error(VncState *vs);
                    303: int vnc_client_io_error(VncState *vs, int ret, int last_errno);
                    304: 
                    305: void start_client_init(VncState *vs);
                    306: void start_auth_vnc(VncState *vs);
                    307: 
                    308: /* Buffer management */
                    309: void buffer_reserve(Buffer *buffer, size_t len);
                    310: int buffer_empty(Buffer *buffer);
                    311: uint8_t *buffer_end(Buffer *buffer);
                    312: void buffer_reset(Buffer *buffer);
                    313: void buffer_append(Buffer *buffer, const void *data, size_t len);
                    314: 
                    315: 
                    316: /* Misc helpers */
                    317: 
                    318: char *vnc_socket_local_addr(const char *format, int fd);
                    319: char *vnc_socket_remote_addr(const char *format, int fd);
                    320: 
                    321: #endif /* __QEMU_VNC_H */

unix.superglobalmegacorp.com