← Back to branch summary

~ubuntu-branches/ubuntu/vivid/freerdp/vivid

« back to all changes in this revision

Viewing changes to channels/drdynvc/drdynvc_main.c

  • Committer: Package Import Robot
  • Author(s): Iain Lane
  • Date: 2014-11-11 12:20:50 UTC
  • mfrom: (1.1.9) (9.1.17 sid)
  • Revision ID: package-import@ubuntu.com-20141111122050-wyr8hrnwco9fcmum
Tags: 1.1.0~git20140921.1.440916e+dfsg1-2ubuntu1
* Merge with Debian unstable, remaining changes
  - Disable ffmpeg support
* Disable gstreamer support, this relies on gstreamer 0.10 and we don't want
  to add any more deps on that.

Show diffs side-by-side

added added

removed removed

Lines of Context:
channels/drdynvc/drdynvc_main.c
1
 
/**
2
 
 * FreeRDP: A Remote Desktop Protocol client.
3
 
 * Dynamic Virtual Channel
4
 
 *
5
 
 * Copyright 2010-2011 Vic Lee
6
 
 *
7
 
 * Licensed under the Apache License, Version 2.0 (the "License");
8
 
 * you may not use this file except in compliance with the License.
9
 
 * You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
#include <stdio.h>
21
 
#include <stdlib.h>
22
 
#include <string.h>
23
 
#include <freerdp/constants.h>
24
 
#include <freerdp/utils/memory.h>
25
 
#include <freerdp/utils/stream.h>
26
 
#include <freerdp/utils/svc_plugin.h>
27
 
#include <freerdp/utils/wait_obj.h>
28
 
 
29
 
#include "dvcman.h"
30
 
#include "drdynvc_types.h"
31
 
#include "drdynvc_main.h"
32
 
 
33
 
#define CREATE_REQUEST_PDU     0x01
34
 
#define DATA_FIRST_PDU         0x02
35
 
#define DATA_PDU               0x03
36
 
#define CLOSE_REQUEST_PDU      0x04
37
 
#define CAPABILITY_REQUEST_PDU 0x05
38
 
 
39
 
struct drdynvc_plugin
40
 
{
41
 
        rdpSvcPlugin plugin;
42
 
 
43
 
        int version;
44
 
        int PriorityCharge0;
45
 
        int PriorityCharge1;
46
 
        int PriorityCharge2;
47
 
        int PriorityCharge3;
48
 
 
49
 
        IWTSVirtualChannelManager* channel_mgr;
50
 
};
51
 
 
52
 
static int drdynvc_write_variable_uint(STREAM* stream, uint32 val)
53
 
{
54
 
        int cb;
55
 
 
56
 
        if (val <= 0xFF)
57
 
        {
58
 
                cb = 0;
59
 
                stream_write_uint8(stream, val);
60
 
        }
61
 
        else if (val <= 0xFFFF)
62
 
        {
63
 
                cb = 1;
64
 
                stream_write_uint16(stream, val);
65
 
        }
66
 
        else
67
 
        {
68
 
                cb = 3;
69
 
                stream_write_uint32(stream, val);
70
 
        }
71
 
        return cb;
72
 
}
73
 
 
74
 
int drdynvc_write_data(drdynvcPlugin* drdynvc, uint32 ChannelId, uint8* data, uint32 data_size)
75
 
{
76
 
        STREAM* data_out;
77
 
        uint32 pos = 0;
78
 
        uint32 cbChId;
79
 
        uint32 cbLen;
80
 
        uint32 chunk_len;
81
 
        int error;
82
 
 
83
 
        DEBUG_DVC("ChannelId=%d size=%d", ChannelId, data_size);
84
 
 
85
 
        data_out = stream_new(CHANNEL_CHUNK_LENGTH);
86
 
        stream_set_pos(data_out, 1);
87
 
        cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
88
 
 
89
 
        if (data_size <= CHANNEL_CHUNK_LENGTH - pos)
90
 
        {
91
 
                pos = stream_get_pos(data_out);
92
 
                stream_set_pos(data_out, 0);
93
 
                stream_write_uint8(data_out, 0x30 | cbChId);
94
 
                stream_set_pos(data_out, pos);
95
 
                stream_write(data_out, data, data_size);
96
 
                error = svc_plugin_send((rdpSvcPlugin*)drdynvc, data_out);
97
 
        }
98
 
        else
99
 
        {
100
 
                /* Fragment the data */
101
 
                cbLen = drdynvc_write_variable_uint(data_out, data_size);
102
 
                pos = stream_get_pos(data_out);
103
 
                stream_set_pos(data_out, 0);
104
 
                stream_write_uint8(data_out, 0x20 | cbChId | (cbLen << 2));
105
 
                stream_set_pos(data_out, pos);
106
 
                chunk_len = CHANNEL_CHUNK_LENGTH - pos;
107
 
                stream_write(data_out, data, chunk_len);
108
 
                data += chunk_len;
109
 
                data_size -= chunk_len;
110
 
                error = svc_plugin_send((rdpSvcPlugin*)drdynvc, data_out);
111
 
 
112
 
                while (error == CHANNEL_RC_OK && data_size > 0)
113
 
                {
114
 
                        data_out = stream_new(CHANNEL_CHUNK_LENGTH);
115
 
                        stream_set_pos(data_out, 1);
116
 
                        cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
117
 
 
118
 
                        pos = stream_get_pos(data_out);
119
 
                        stream_set_pos(data_out, 0);
120
 
                        stream_write_uint8(data_out, 0x30 | cbChId);
121
 
                        stream_set_pos(data_out, pos);
122
 
 
123
 
                        chunk_len = data_size;
124
 
                        if (chunk_len > CHANNEL_CHUNK_LENGTH - pos)
125
 
                                chunk_len = CHANNEL_CHUNK_LENGTH - pos;
126
 
                        stream_write(data_out, data, chunk_len);
127
 
                        data += chunk_len;
128
 
                        data_size -= chunk_len;
129
 
                        error = svc_plugin_send((rdpSvcPlugin*)drdynvc, data_out);
130
 
                }
131
 
        }
132
 
        if (error != CHANNEL_RC_OK)
133
 
        {
134
 
                DEBUG_WARN("VirtualChannelWrite failed %d", error);
135
 
                return 1;
136
 
        }
137
 
        return 0;
138
 
}
139
 
 
140
 
int drdynvc_push_event(drdynvcPlugin* drdynvc, RDP_EVENT* event)
141
 
{
142
 
        int error;
143
 
 
144
 
        error = svc_plugin_send_event((rdpSvcPlugin*)drdynvc, event);
145
 
        if (error != CHANNEL_RC_OK)
146
 
        {
147
 
                DEBUG_WARN("pVirtualChannelEventPush failed %d", error);
148
 
                return 1;
149
 
        }
150
 
        return 0;
151
 
}
152
 
 
153
 
static int drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
154
 
{
155
 
        STREAM* data_out;
156
 
        int error;
157
 
 
158
 
        DEBUG_DVC("Sp=%d cbChId=%d", Sp, cbChId);
159
 
        stream_seek(s, 1); /* pad */
160
 
        stream_read_uint16(s, drdynvc->version);
161
 
        if (drdynvc->version == 2)
162
 
        {
163
 
                stream_read_uint16(s, drdynvc->PriorityCharge0);
164
 
                stream_read_uint16(s, drdynvc->PriorityCharge1);
165
 
                stream_read_uint16(s, drdynvc->PriorityCharge2);
166
 
                stream_read_uint16(s, drdynvc->PriorityCharge3);
167
 
        }
168
 
        data_out = stream_new(4);
169
 
        stream_write_uint16(data_out, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
170
 
        stream_write_uint16(data_out, drdynvc->version);
171
 
        error = svc_plugin_send((rdpSvcPlugin*)drdynvc, data_out);
172
 
        if (error != CHANNEL_RC_OK)
173
 
        {
174
 
                DEBUG_WARN("VirtualChannelWrite failed %d", error);
175
 
                return 1;
176
 
        }
177
 
        return 0;
178
 
}
179
 
 
180
 
static uint32 drdynvc_read_variable_uint(STREAM* stream, int cbLen)
181
 
{
182
 
        uint32 val;
183
 
 
184
 
        switch (cbLen)
185
 
        {
186
 
                case 0:
187
 
                        stream_read_uint8(stream, val);
188
 
                        break;
189
 
                case 1:
190
 
                        stream_read_uint16(stream, val);
191
 
                        break;
192
 
                default:
193
 
                        stream_read_uint32(stream, val);
194
 
                        break;
195
 
        }
196
 
        return val;
197
 
}
198
 
 
199
 
static int drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
200
 
{
201
 
        STREAM* data_out;
202
 
        int pos;
203
 
        int error;
204
 
        uint32 ChannelId;
205
 
 
206
 
        ChannelId = drdynvc_read_variable_uint(s, cbChId);
207
 
        pos = stream_get_pos(s);
208
 
        DEBUG_DVC("ChannelId=%d ChannelName=%s", ChannelId, stream_get_tail(s));
209
 
 
210
 
        error = dvcman_create_channel(drdynvc->channel_mgr, ChannelId, (char*)stream_get_tail(s));
211
 
 
212
 
        data_out = stream_new(pos + 4);
213
 
        stream_write_uint8(data_out, 0x10 | cbChId);
214
 
        stream_set_pos(s, 1);
215
 
        stream_copy(data_out, s, pos - 1);
216
 
        
217
 
        if (error == 0)
218
 
        {
219
 
                DEBUG_DVC("channel created");
220
 
                stream_write_uint32(data_out, 0);
221
 
        }
222
 
        else
223
 
        {
224
 
                DEBUG_DVC("no listener");
225
 
                stream_write_uint32(data_out, (uint32)(-1));
226
 
        }
227
 
 
228
 
        error = svc_plugin_send((rdpSvcPlugin*)drdynvc, data_out);
229
 
        if (error != CHANNEL_RC_OK)
230
 
        {
231
 
                DEBUG_WARN("VirtualChannelWrite failed %d", error);
232
 
                return 1;
233
 
        }
234
 
        return 0;
235
 
}
236
 
 
237
 
static int drdynvc_process_data_first(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
238
 
{
239
 
        uint32 ChannelId;
240
 
        uint32 Length;
241
 
        int error;
242
 
 
243
 
        ChannelId = drdynvc_read_variable_uint(s, cbChId);
244
 
        Length = drdynvc_read_variable_uint(s, Sp);
245
 
        DEBUG_DVC("ChannelId=%d Length=%d", ChannelId, Length);
246
 
 
247
 
        error = dvcman_receive_channel_data_first(drdynvc->channel_mgr, ChannelId, Length);
248
 
        if (error)
249
 
                return error;
250
 
 
251
 
        return dvcman_receive_channel_data(drdynvc->channel_mgr, ChannelId,
252
 
                stream_get_tail(s), stream_get_left(s));
253
 
}
254
 
 
255
 
static int drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
256
 
{
257
 
        uint32 ChannelId;
258
 
 
259
 
        ChannelId = drdynvc_read_variable_uint(s, cbChId);
260
 
        DEBUG_DVC("ChannelId=%d", ChannelId);
261
 
 
262
 
        return dvcman_receive_channel_data(drdynvc->channel_mgr, ChannelId,
263
 
                stream_get_tail(s), stream_get_left(s));
264
 
}
265
 
 
266
 
static int drdynvc_process_close_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, STREAM* s)
267
 
{
268
 
        uint32 ChannelId;
269
 
 
270
 
        ChannelId = drdynvc_read_variable_uint(s, cbChId);
271
 
        DEBUG_DVC("ChannelId=%d", ChannelId);
272
 
        dvcman_close_channel(drdynvc->channel_mgr, ChannelId);
273
 
 
274
 
        return 0;
275
 
}
276
 
 
277
 
static void drdynvc_process_receive(rdpSvcPlugin* plugin, STREAM* s)
278
 
{
279
 
        drdynvcPlugin* drdynvc = (drdynvcPlugin*)plugin;
280
 
        int value;
281
 
        int Cmd;
282
 
        int Sp;
283
 
        int cbChId;
284
 
 
285
 
        stream_read_uint8(s, value);
286
 
        Cmd = (value & 0xf0) >> 4;
287
 
        Sp = (value & 0x0c) >> 2;
288
 
        cbChId = (value & 0x03) >> 0;
289
 
 
290
 
        DEBUG_DVC("Cmd=0x%x", Cmd);
291
 
 
292
 
        switch (Cmd)
293
 
        {
294
 
                case CAPABILITY_REQUEST_PDU:
295
 
                        drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
296
 
                        break;
297
 
                case CREATE_REQUEST_PDU:
298
 
                        drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
299
 
                        break;
300
 
                case DATA_FIRST_PDU:
301
 
                        drdynvc_process_data_first(drdynvc, Sp, cbChId, s);
302
 
                        break;
303
 
                case DATA_PDU:
304
 
                        drdynvc_process_data(drdynvc, Sp, cbChId, s);
305
 
                        break;
306
 
                case CLOSE_REQUEST_PDU:
307
 
                        drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
308
 
                        break;
309
 
                default:
310
 
                        DEBUG_WARN("unknown drdynvc cmd 0x%x", Cmd);
311
 
                        break;
312
 
        }
313
 
 
314
 
        stream_free(s);
315
 
}
316
 
 
317
 
static void drdynvc_process_connect(rdpSvcPlugin* plugin)
318
 
{
319
 
        drdynvcPlugin* drdynvc = (drdynvcPlugin*)plugin;
320
 
 
321
 
        DEBUG_DVC("connecting");
322
 
 
323
 
        drdynvc->channel_mgr = dvcman_new(drdynvc);
324
 
        dvcman_load_plugin(drdynvc->channel_mgr, svc_plugin_get_data(plugin));
325
 
        dvcman_init(drdynvc->channel_mgr);
326
 
}
327
 
 
328
 
static void drdynvc_process_event(rdpSvcPlugin* plugin, RDP_EVENT* event)
329
 
{
330
 
        freerdp_event_free(event);
331
 
}
332
 
 
333
 
static void drdynvc_process_terminate(rdpSvcPlugin* plugin)
334
 
{
335
 
        drdynvcPlugin* drdynvc = (drdynvcPlugin*)plugin;
336
 
 
337
 
        DEBUG_DVC("terminating");
338
 
 
339
 
        if (drdynvc->channel_mgr != NULL)
340
 
                dvcman_free(drdynvc->channel_mgr);
341
 
        xfree(drdynvc);
342
 
}
343
 
 
344
 
DEFINE_SVC_PLUGIN(drdynvc, "drdynvc",
345
 
        CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP |
346
 
        CHANNEL_OPTION_COMPRESS_RDP)