trunk/rdesktop/cliprdr.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   Protocol services - Clipboard functions
   Copyright (C) Erik Forsberg <forsberg@cendio.se> 2003
   Copyright (C) Matthew Chapman 2003

   This program 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 program 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 program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "rdesktop.h"

#define CLIPRDR_CONNECT                 1
#define CLIPRDR_FORMAT_ANNOUNCE         2
#define CLIPRDR_FORMAT_ACK              3
#define CLIPRDR_DATA_REQUEST            4
#define CLIPRDR_DATA_RESPONSE           5

#define CLIPRDR_REQUEST                 0
#define CLIPRDR_RESPONSE                1
#define CLIPRDR_ERROR                   2

static VCHANNEL *cliprdr_channel;

static void
cliprdr_send_packet(uint16 type, uint16 status, uint8 * data, uint32 length)
{
        STREAM s;

        DEBUG_CLIPBOARD(("CLIPRDR send: type=%d, status=%d, length=%d\n", type, status, length));

        s = channel_init(cliprdr_channel, length + 12);
        out_uint16_le(s, type);
        out_uint16_le(s, status);
        out_uint32_le(s, length);
        out_uint8p(s, data, length);
        out_uint32(s, 0);       /* pad? */
        s_mark_end(s);
        channel_send(s, cliprdr_channel);
}

void
cliprdr_send_text_format_announce(void)
{
        uint8 buffer[36];

        buf_out_uint32(buffer, CF_TEXT);
        memset(buffer + 4, 0, sizeof(buffer) - 4);      /* description */
        cliprdr_send_packet(CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, buffer, sizeof(buffer));
}

void
cliprdr_send_blah_format_announce(void)
{
        uint8 buffer[36];

        buf_out_uint32(buffer, CF_OEMTEXT);
        memset(buffer + 4, 0, sizeof(buffer) - 4);      /* description */
        cliprdr_send_packet(CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, buffer, sizeof(buffer));
}

void
cliprdr_send_native_format_announce(uint8 * data, uint32 length)
{
        cliprdr_send_packet(CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, data, length);
}

void
cliprdr_send_data_request(uint32 format)
{
        uint8 buffer[4];

        buf_out_uint32(buffer, format);
        cliprdr_send_packet(CLIPRDR_DATA_REQUEST, CLIPRDR_REQUEST, buffer, sizeof(buffer));
}

void
cliprdr_send_data(uint8 * data, uint32 length)
{
        cliprdr_send_packet(CLIPRDR_DATA_RESPONSE, CLIPRDR_RESPONSE, data, length);
}

static void
cliprdr_process(STREAM s)
{
        uint16 type, status;
        uint32 length, format;
        char *data;

        in_uint16_le(s, type);
        in_uint16_le(s, status);
        in_uint32_le(s, length);
        data = s->p;

        DEBUG_CLIPBOARD(("CLIPRDR recv: type=%d, status=%d, length=%d\n", type, status, length));

        if (status == CLIPRDR_ERROR)
        {
                if (type == CLIPRDR_FORMAT_ACK)
                {
                        /* FIXME: We seem to get this when we send an announce while the server is
                           still processing a paste. Try sending another announce. */
                        cliprdr_send_text_format_announce();
                        return;
                }

                error("CLIPRDR error (type=%d)\n", type);
                return;
        }

        switch (type)
        {
                case CLIPRDR_CONNECT:
                        ui_clip_sync();
                        break;
                case CLIPRDR_FORMAT_ANNOUNCE:
                        ui_clip_format_announce(data, length);
                        cliprdr_send_packet(CLIPRDR_FORMAT_ACK, CLIPRDR_RESPONSE, NULL, 0);
                        return;
                case CLIPRDR_FORMAT_ACK:
                        break;
                case CLIPRDR_DATA_REQUEST:
                        in_uint32_le(s, format);
                        ui_clip_request_data(format);
                        break;
                case CLIPRDR_DATA_RESPONSE:
                        ui_clip_handle_data(data, length);
                        break;
                default:
                        unimpl("CLIPRDR packet type %d\n", type);
        }
}

BOOL
cliprdr_init(void)
{
        cliprdr_channel =
                channel_register("cliprdr",
                                 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP |
                                 CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL,
                                 cliprdr_process);
        return (cliprdr_channel != NULL);
}
1	forsberg	383	/* -- c-basic-offset: 8 --
2			rdesktop: A Remote Desktop Protocol client.
3			Protocol services - Clipboard functions
4			Copyright (C) Erik Forsberg <forsberg@cendio.se> 2003
5	matthewc	432	Copyright (C) Matthew Chapman 2003
6	forsberg	383
7			This program is free software; you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation; either version 2 of the License, or
10			(at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20			*/
21
22			#include "rdesktop.h"
23
24	matthewc	432	#define CLIPRDR_CONNECT 1
25			#define CLIPRDR_FORMAT_ANNOUNCE 2
26			#define CLIPRDR_FORMAT_ACK 3
27			#define CLIPRDR_DATA_REQUEST 4
28			#define CLIPRDR_DATA_RESPONSE 5
29	forsberg	383
30	matthewc	432	#define CLIPRDR_REQUEST 0
31			#define CLIPRDR_RESPONSE 1
32			#define CLIPRDR_ERROR 2
33	forsberg	383
34	matthewc	432	static VCHANNEL *cliprdr_channel;
35	forsberg	396
36	forsberg	386	static void
37	astrand	435	cliprdr_send_packet(uint16 type, uint16 status, uint8 * data, uint32 length)
38	forsberg	387	{
39	forsberg	395	STREAM s;
40	forsberg	387
41	matthewc	432	DEBUG_CLIPBOARD(("CLIPRDR send: type=%d, status=%d, length=%d\n", type, status, length));
42	forsberg	387
43	matthewc	432	s = channel_init(cliprdr_channel, length + 12);
44			out_uint16_le(s, type);
45			out_uint16_le(s, status);
46	forsberg	394	out_uint32_le(s, length);
47			out_uint8p(s, data, length);
48	astrand	435	out_uint32(s, 0); /* pad? */
49	forsberg	394	s_mark_end(s);
50	matthewc	432	channel_send(s, cliprdr_channel);
51	forsberg	394	}
52
53	matthewc	432	void
54			cliprdr_send_text_format_announce(void)
55	forsberg	386	{
56	matthewc	432	uint8 buffer[36];
57	forsberg	396
58	matthewc	432	buf_out_uint32(buffer, CF_TEXT);
59	astrand	435	memset(buffer + 4, 0, sizeof(buffer) - 4); /* description */
60	matthewc	432	cliprdr_send_packet(CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, buffer, sizeof(buffer));
61	forsberg	386	}
62
63	forsberg	396	void
64	matthewc	432	cliprdr_send_blah_format_announce(void)
65	forsberg	383	{
66	matthewc	432	uint8 buffer[36];
67	forsberg	386
68	matthewc	432	buf_out_uint32(buffer, CF_OEMTEXT);
69	astrand	435	memset(buffer + 4, 0, sizeof(buffer) - 4); /* description */
70	matthewc	432	cliprdr_send_packet(CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, buffer, sizeof(buffer));
71	forsberg	383	}
72
73			void
74	astrand	435	cliprdr_send_native_format_announce(uint8 * data, uint32 length)
75	forsberg	383	{
76	matthewc	432	cliprdr_send_packet(CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, data, length);
77	forsberg	383	}
78
79	matthewc	432	void
80			cliprdr_send_data_request(uint32 format)
81	forsberg	384	{
82	matthewc	432	uint8 buffer[4];
83	forsberg	384
84	matthewc	432	buf_out_uint32(buffer, format);
85			cliprdr_send_packet(CLIPRDR_DATA_REQUEST, CLIPRDR_REQUEST, buffer, sizeof(buffer));
86	forsberg	384	}
87
88	forsberg	383	void
89	astrand	435	cliprdr_send_data(uint8 * data, uint32 length)
90	forsberg	383	{
91	matthewc	432	cliprdr_send_packet(CLIPRDR_DATA_RESPONSE, CLIPRDR_RESPONSE, data, length);
92	forsberg	384	}
93	forsberg	383
94	forsberg	396	static void
95	matthewc	432	cliprdr_process(STREAM s)
96	forsberg	384	{
97	matthewc	432	uint16 type, status;
98			uint32 length, format;
99			char *data;
100	forsberg	384
101	matthewc	432	in_uint16_le(s, type);
102			in_uint16_le(s, status);
103			in_uint32_le(s, length);
104			data = s->p;
105	forsberg	384
106	matthewc	432	DEBUG_CLIPBOARD(("CLIPRDR recv: type=%d, status=%d, length=%d\n", type, status, length));
107	forsberg	383
108	matthewc	432	if (status == CLIPRDR_ERROR)
109	forsberg	396	{
110	matthewc	432	if (type == CLIPRDR_FORMAT_ACK)
111	forsberg	396	{
112	matthewc	432	/* FIXME: We seem to get this when we send an announce while the server is
113			still processing a paste. Try sending another announce. */
114			cliprdr_send_text_format_announce();
115			return;
116	forsberg	383	}
117
118	matthewc	432	error("CLIPRDR error (type=%d)\n", type);
119	forsberg	392	return;
120	forsberg	396	}
121	forsberg	392
122	matthewc	432	switch (type)
123	forsberg	392	{
124	matthewc	432	case CLIPRDR_CONNECT:
125			ui_clip_sync();
126			break;
127			case CLIPRDR_FORMAT_ANNOUNCE:
128			ui_clip_format_announce(data, length);
129			cliprdr_send_packet(CLIPRDR_FORMAT_ACK, CLIPRDR_RESPONSE, NULL, 0);
130	forsberg	383	return;
131	matthewc	432	case CLIPRDR_FORMAT_ACK:
132			break;
133			case CLIPRDR_DATA_REQUEST:
134			in_uint32_le(s, format);
135			ui_clip_request_data(format);
136			break;
137			case CLIPRDR_DATA_RESPONSE:
138			ui_clip_handle_data(data, length);
139			break;
140			default:
141			unimpl("CLIPRDR packet type %d\n", type);
142	forsberg	396	}
143	forsberg	383	}
144
145	matthewc	432	BOOL
146	forsberg	396	cliprdr_init(void)
147	forsberg	383	{
148	astrand	435	cliprdr_channel =
149			channel_register("cliprdr",
150			CHANNEL_OPTION_INITIALIZED \| CHANNEL_OPTION_ENCRYPT_RDP \|
151			CHANNEL_OPTION_COMPRESS_RDP \| CHANNEL_OPTION_SHOW_PROTOCOL,
152			cliprdr_process);
153	matthewc	432	return (cliprdr_channel != NULL);
154	forsberg	383	}