« back to all changes in this revision
Viewing changes to libfreerdp-channels/libchannels.c
- browse files at revision 13
- compare with another revision
- download diff
- download tarball
- view history from revision 13
- Committer: Package Import Robot
- Author(s): Otavio Salvador, Jeremy Bicha
- Date: 2012-02-11 10:34:05 UTC
- mfrom: (1.1.7) (9.1.3 sid)
- Revision ID: package-import@ubuntu.com-20120211103405-mk0gjhjn70eeyxul
Tags: 1.0.1-1
[ Jeremy Bicha ]
* New upstream release. Closes: #659332.
* Updated symbols
* New upstream release. Closes: #659332.
* Updated symbols
- files added:
- libfreerdp-gdi/include
- files removed:
- include/freerdp/utils/certstore.h
- files modified:
- CMakeLists.txt
added
removed
libfreerdp-channels/libchannels.c
79
79
typedef struct rdp_init_handle rdpInitHandle;
80
80
struct rdp_init_handle
81
81
{
82
rdpChannels* chan_man;
82
rdpChannels* channels;
83
83
};
84
84
85
85
struct rdp_channels
92
92
* own array items
93
93
* ie, no two threads can access index 0, ...
94
94
*/
95
struct lib_data libs[CHANNEL_MAX_COUNT];
96
int num_libs;
97
struct channel_data chans[CHANNEL_MAX_COUNT];
98
int num_chans;
95
96
struct lib_data libs_data[CHANNEL_MAX_COUNT];
97
int num_libs_data;
98
99
struct channel_data channels_data[CHANNEL_MAX_COUNT];
100
int num_channels_data;
101
99
102
rdpInitHandle init_handles[CHANNEL_MAX_COUNT];
100
103
int num_init_handles;
101
104
106
109
/* true once freerdp_chanman_post_connect is called */
107
110
int is_connected;
108
111
109
/* used for locating the chan_man for a given instance */
112
/* used for locating the channels for a given instance */
110
113
freerdp* instance;
111
114
112
115
/* signal for incoming data or event */
125
128
* The current channel manager reference passes from VirtualChannelEntry to
126
129
* VirtualChannelInit for the pInitHandle.
127
130
*/
128
static rdpChannels* g_init_chan_man;
131
static rdpChannels* g_init_channels;
129
132
130
133
/* The list of all channel managers. */
131
134
typedef struct rdp_channels_list rdpChannelsList;
144
147
static freerdp_mutex g_mutex_init;
145
148
static freerdp_mutex g_mutex_list;
146
149
147
/* returns the chan_man for the open handle passed in */
150
/* returns the channels for the open handle passed in */
148
151
static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* pindex)
149
152
{
150
rdpChannelsList* list;
151
rdpChannels* chan_man;
152
153
int lindex;
154
rdpChannels* channels;
155
rdpChannelsList* channels_list;
153
156
154
157
freerdp_mutex_lock(g_mutex_list);
155
for (list = g_channels_list; list; list = list->next)
158
159
for (channels_list = g_channels_list; channels_list; channels_list = channels_list->next)
156
160
{
157
chan_man = list->channels;
158
for (lindex = 0; lindex < chan_man->num_chans; lindex++)
161
channels = channels_list->channels;
162
163
for (lindex = 0; lindex < channels->num_channels_data; lindex++)
159
164
{
160
if (chan_man->chans[lindex].open_handle == open_handle)
165
if (channels->channels_data[lindex].open_handle == open_handle)
161
166
{
162
167
freerdp_mutex_unlock(g_mutex_list);
163
168
*pindex = lindex;
164
return chan_man;
169
return channels;
165
170
}
166
171
}
167
172
}
173
168
174
freerdp_mutex_unlock(g_mutex_list);
175
169
176
return NULL;
170
177
}
171
178
172
/* returns the chan_man for the rdp instance passed in */
179
/* returns the channels for the rdp instance passed in */
173
180
static rdpChannels* freerdp_channels_find_by_instance(freerdp* instance)
174
181
{
175
rdpChannelsList* list;
176
rdpChannels* chan_man;
182
rdpChannels* channels;
183
rdpChannelsList* channels_list;
177
184
178
185
freerdp_mutex_lock(g_mutex_list);
179
for (list = g_channels_list; list; list = list->next)
186
187
for (channels_list = g_channels_list; channels_list; channels_list = channels_list->next)
180
188
{
181
chan_man = list->channels;
182
if (chan_man->instance == instance)
189
channels = channels_list->channels;
190
if (channels->instance == instance)
183
191
{
184
192
freerdp_mutex_unlock(g_mutex_list);
185
return chan_man;
193
return channels;
186
194
}
187
195
}
196
188
197
freerdp_mutex_unlock(g_mutex_list);
189
return NULL;
190
}
191
192
/* returns struct chan_data for the channel name passed in */
193
static struct channel_data* freerdp_channels_find_channel_data_by_name(rdpChannels* chan_man,
194
const char* chan_name, int* pindex)
195
{
196
int lindex;
197
struct channel_data* lchan_data;
198
199
for (lindex = 0; lindex < chan_man->num_chans; lindex++)
200
{
201
lchan_data = chan_man->chans + lindex;
202
if (strcmp(chan_name, lchan_data->name) == 0)
203
{
204
if (pindex != 0)
205
{
206
*pindex = lindex;
207
}
208
return lchan_data;
209
}
210
}
211
return NULL;
212
}
213
214
/* returns rdpChan for the channel id passed in */
215
static rdpChannel* freerdp_channels_find_channel_by_id(rdpChannels* channels,
216
rdpSettings* settings, int channel_id, int* pindex)
217
{
218
int lindex;
219
int lcount;
220
rdpChannel* lrdp_chan;
221
222
lcount = settings->num_channels;
223
for (lindex = 0; lindex < lcount; lindex++)
224
{
225
lrdp_chan = settings->channels + lindex;
226
if (lrdp_chan->channel_id == channel_id)
227
{
228
if (pindex != 0)
229
*pindex = lindex;
230
231
return lrdp_chan;
232
}
233
}
234
return NULL;
235
}
236
237
/* returns rdpChan for the channel name passed in */
238
static rdpChannel* freerdp_channels_find_channel_by_name(rdpChannels* chan_man,
239
rdpSettings* settings, const char* chan_name, int* pindex)
240
{
241
int lindex;
242
int lcount;
243
rdpChannel* lrdp_chan;
244
245
lcount = settings->num_channels;
246
for (lindex = 0; lindex < lcount; lindex++)
247
{
248
lrdp_chan = settings->channels + lindex;
249
if (strcmp(chan_name, lrdp_chan->name) == 0)
250
{
251
if (pindex != 0)
252
*pindex = lindex;
253
254
return lrdp_chan;
255
}
256
}
198
199
return NULL;
200
}
201
202
/* returns struct channel_data for the channel name passed in */
203
static struct channel_data* freerdp_channels_find_channel_data_by_name(rdpChannels* channels, const char* channel_name, int* pindex)
204
{
205
int lindex;
206
struct channel_data* lchannel_data;
207
208
for (lindex = 0; lindex < channels->num_channels_data; lindex++)
209
{
210
lchannel_data = channels->channels_data + lindex;
211
212
if (strcmp(channel_name, lchannel_data->name) == 0)
213
{
214
if (pindex != 0)
215
*pindex = lindex;
216
217
return lchannel_data;
218
}
219
}
220
221
return NULL;
222
}
223
224
/* returns rdpChannel for the channel id passed in */
225
static rdpChannel* freerdp_channels_find_channel_by_id(rdpChannels* channels, rdpSettings* settings, int channel_id, int* pindex)
226
{
227
int lindex;
228
int lcount;
229
rdpChannel* lrdp_channel;
230
231
lcount = settings->num_channels;
232
233
for (lindex = 0; lindex < lcount; lindex++)
234
{
235
lrdp_channel = settings->channels + lindex;
236
237
if (lrdp_channel->channel_id == channel_id)
238
{
239
if (pindex != 0)
240
*pindex = lindex;
241
242
return lrdp_channel;
243
}
244
}
245
246
return NULL;
247
}
248
249
/* returns rdpChannel for the channel name passed in */
250
static rdpChannel* freerdp_channels_find_channel_by_name(rdpChannels* channels,
251
rdpSettings* settings, const char* channel_name, int* pindex)
252
{
253
int lindex;
254
int lcount;
255
rdpChannel* lrdp_channel;
256
257
lcount = settings->num_channels;
258
259
for (lindex = 0; lindex < lcount; lindex++)
260
{
261
lrdp_channel = settings->channels + lindex;
262
263
if (strcmp(channel_name, lrdp_channel->name) == 0)
264
{
265
if (pindex != 0)
266
*pindex = lindex;
267
268
return lrdp_channel;
269
}
270
}
271
257
272
return NULL;
258
273
}
259
274
263
278
* only called from main thread
264
279
*/
265
280
static uint32 FREERDP_CC MyVirtualChannelInit(void** ppInitHandle, PCHANNEL_DEF pChannel,
266
int channelCount, uint32 versionRequested,
267
PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
281
int channelCount, uint32 versionRequested, PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
268
282
{
269
rdpChannels* chan_man;
270
283
int index;
284
rdpChannels* channels;
271
285
struct lib_data* llib;
272
struct channel_data* lchan;
273
rdpChannel* lrdp_chan;
274
PCHANNEL_DEF lchan_def;
286
rdpChannel* lrdp_channel;
287
PCHANNEL_DEF lchannel_def;
288
struct channel_data* lchannel_data;
275
289
276
chan_man = g_init_chan_man;
277
chan_man->init_handles[chan_man->num_init_handles].chan_man = chan_man;
278
*ppInitHandle = &chan_man->init_handles[chan_man->num_init_handles];
279
chan_man->num_init_handles++;
290
channels = g_init_channels;
291
channels->init_handles[channels->num_init_handles].channels = channels;
292
*ppInitHandle = &channels->init_handles[channels->num_init_handles];
293
channels->num_init_handles++;
280
294
281
295
DEBUG_CHANNELS("enter");
282
if (!chan_man->can_call_init)
296
297
if (!channels->can_call_init)
283
298
{
284
299
DEBUG_CHANNELS("error not in entry");
285
300
return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
286
301
}
302
287
303
if (ppInitHandle == 0)
288
304
{
289
305
DEBUG_CHANNELS("error bad pphan");
290
306
return CHANNEL_RC_BAD_INIT_HANDLE;
291
307
}
292
if (chan_man->num_chans + channelCount >= CHANNEL_MAX_COUNT)
308
309
if (channels->num_channels_data + channelCount >= CHANNEL_MAX_COUNT)
293
310
{
294
311
DEBUG_CHANNELS("error too many channels");
295
312
return CHANNEL_RC_TOO_MANY_CHANNELS;
296
313
}
314
297
315
if (pChannel == 0)
298
316
{
299
317
DEBUG_CHANNELS("error bad pchan");
300
318
return CHANNEL_RC_BAD_CHANNEL;
301
319
}
302
if (chan_man->is_connected)
320
321
if (channels->is_connected)
303
322
{
304
323
DEBUG_CHANNELS("error already connected");
305
324
return CHANNEL_RC_ALREADY_CONNECTED;
306
325
}
326
307
327
if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
308
328
{
309
329
DEBUG_CHANNELS("warning version");
310
330
}
331
311
332
for (index = 0; index < channelCount; index++)
312
333
{
313
lchan_def = pChannel + index;
314
if (freerdp_channels_find_channel_data_by_name(chan_man, lchan_def->name, 0) != 0)
334
lchannel_def = pChannel + index;
335
if (freerdp_channels_find_channel_data_by_name(channels, lchannel_def->name, 0) != 0)
315
336
{
316
337
DEBUG_CHANNELS("error channel already used");
317
338
return CHANNEL_RC_BAD_CHANNEL;
318
339
}
319
340
}
320
llib = chan_man->libs + chan_man->num_libs;
341
342
llib = channels->libs_data + channels->num_libs_data;
321
343
llib->init_event_proc = pChannelInitEventProc;
322
344
llib->init_handle = *ppInitHandle;
323
chan_man->num_libs++;
345
channels->num_libs_data++;
346
324
347
for (index = 0; index < channelCount; index++)
325
348
{
326
lchan_def = pChannel + index;
327
lchan = chan_man->chans + chan_man->num_chans;
349
lchannel_def = pChannel + index;
350
lchannel_data = channels->channels_data + channels->num_channels_data;
328
351
329
352
freerdp_mutex_lock(g_mutex_list);
330
lchan->open_handle = g_open_handle_sequence++;
353
lchannel_data->open_handle = g_open_handle_sequence++;
331
354
freerdp_mutex_unlock(g_mutex_list);
332
355
333
lchan->flags = 1; /* init */
334
strncpy(lchan->name, lchan_def->name, CHANNEL_NAME_LEN);
335
lchan->options = lchan_def->options;
336
if (chan_man->settings->num_channels < 16)
356
lchannel_data->flags = 1; /* init */
357
strncpy(lchannel_data->name, lchannel_def->name, CHANNEL_NAME_LEN);
358
lchannel_data->options = lchannel_def->options;
359
360
if (channels->settings->num_channels < 16)
337
361
{
338
lrdp_chan = chan_man->settings->channels + chan_man->settings->num_channels;
339
strncpy(lrdp_chan->name, lchan_def->name, 7);
340
lrdp_chan->options = lchan_def->options;
341
chan_man->settings->num_channels++;
362
lrdp_channel = channels->settings->channels + channels->settings->num_channels;
363
strncpy(lrdp_channel->name, lchannel_def->name, 7);
364
lrdp_channel->options = lchannel_def->options;
365
channels->settings->num_channels++;
342
366
}
343
367
else
344
368
{
345
369
DEBUG_CHANNELS("warning more than 16 channels");
346
370
}
347
chan_man->num_chans++;
371
372
channels->num_channels_data++;
348
373
}
374
349
375
return CHANNEL_RC_OK;
350
376
}
351
377
356
382
static uint32 FREERDP_CC MyVirtualChannelOpen(void* pInitHandle, uint32* pOpenHandle,
357
383
char* pChannelName, PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
358
384
{
359
rdpChannels* chan_man;
360
385
int index;
361
struct channel_data* lchan;
386
rdpChannels* channels;
387
struct channel_data* lchannel_data;
362
388
363
389
DEBUG_CHANNELS("enter");
364
chan_man = ((rdpInitHandle*)pInitHandle)->chan_man;
390
391
channels = ((rdpInitHandle*) pInitHandle)->channels;
392
365
393
if (pOpenHandle == 0)
366
394
{
367
395
DEBUG_CHANNELS("error bad chanhan");
368
396
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
369
397
}
398
370
399
if (pChannelOpenEventProc == 0)
371
400
{
372
401
DEBUG_CHANNELS("error bad proc");
373
402
return CHANNEL_RC_BAD_PROC;
374
403
}
375
if (!chan_man->is_connected)
404
405
if (!channels->is_connected)
376
406
{
377
407
DEBUG_CHANNELS("error not connected");
378
408
return CHANNEL_RC_NOT_CONNECTED;
379
409
}
380
lchan = freerdp_channels_find_channel_data_by_name(chan_man, pChannelName, &index);
381
if (lchan == 0)
410
411
lchannel_data = freerdp_channels_find_channel_data_by_name(channels, pChannelName, &index);
412
413
if (lchannel_data == 0)
382
414
{
383
415
DEBUG_CHANNELS("error chan name");
384
416
return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
385
417
}
386
if (lchan->flags == 2)
418
419
if (lchannel_data->flags == 2)
387
420
{
388
421
DEBUG_CHANNELS("error chan already open");
389
422
return CHANNEL_RC_ALREADY_OPEN;
390
423
}
391
424
392
lchan->flags = 2; /* open */
393
lchan->open_event_proc = pChannelOpenEventProc;
394
*pOpenHandle = lchan->open_handle;
425
lchannel_data->flags = 2; /* open */
426
lchannel_data->open_event_proc = pChannelOpenEventProc;
427
*pOpenHandle = lchannel_data->open_handle;
428
395
429
return CHANNEL_RC_OK;
396
430
}
397
431
401
435
*/
402
436
static uint32 FREERDP_CC MyVirtualChannelClose(uint32 openHandle)
403
437
{
404
rdpChannels* chan_man;
405
struct channel_data* lchan;
406
438
int index;
439
rdpChannels* channels;
440
struct channel_data* lchannel_data;
407
441
408
442
DEBUG_CHANNELS("enter");
409
chan_man = freerdp_channels_find_by_open_handle(openHandle, &index);
410
if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
443
444
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
445
446
if ((channels == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
411
447
{
412
DEBUG_CHANNELS("error bad chanhan");
448
DEBUG_CHANNELS("error bad channels");
413
449
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
414
450
}
415
lchan = chan_man->chans + index;
416
if (lchan->flags != 2)
451
452
lchannel_data = channels->channels_data + index;
453
454
if (lchannel_data->flags != 2)
417
455
{
418
456
DEBUG_CHANNELS("error not open");
419
457
return CHANNEL_RC_NOT_OPEN;
420
458
}
421
lchan->flags = 0;
459
460
lchannel_data->flags = 0;
461
422
462
return CHANNEL_RC_OK;
423
463
}
424
464
425
465
/* can be called from any thread */
426
static uint32 FREERDP_CC MyVirtualChannelWrite(uint32 openHandle, void* pData, uint32 dataLength,
427
void* pUserData)
466
static uint32 FREERDP_CC MyVirtualChannelWrite(uint32 openHandle, void* pData, uint32 dataLength, void* pUserData)
428
467
{
429
rdpChannels* chan_man;
430
struct channel_data* lchan;
468
int index;
469
rdpChannels* channels;
431
470
struct sync_data* item;
432
int index;
433
434
chan_man = freerdp_channels_find_by_open_handle(openHandle, &index);
435
if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
471
struct channel_data* lchannel_data;
472
473
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
474
475
if ((channels == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
436
476
{
437
477
DEBUG_CHANNELS("error bad chanhan");
438
478
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
439
479
}
440
if (!chan_man->is_connected)
480
481
if (!channels->is_connected)
441
482
{
442
483
DEBUG_CHANNELS("error not connected");
443
484
return CHANNEL_RC_NOT_CONNECTED;
444
485
}
486
445
487
if (pData == 0)
446
488
{
447
489
DEBUG_CHANNELS("error bad pData");
448
490
return CHANNEL_RC_NULL_DATA;
449
491
}
492
450
493
if (dataLength == 0)
451
494
{
452
495
DEBUG_CHANNELS("error bad dataLength");
453
496
return CHANNEL_RC_ZERO_LENGTH;
454
497
}
455
lchan = chan_man->chans + index;
456
if (lchan->flags != 2)
498
499
lchannel_data = channels->channels_data + index;
500
501
if (lchannel_data->flags != 2)
457
502
{
458
503
DEBUG_CHANNELS("error not open");
459
504
return CHANNEL_RC_NOT_OPEN;
460
505
}
461
freerdp_mutex_lock(chan_man->sync_data_mutex); /* lock channels->sync* vars */
462
if (!chan_man->is_connected)
506
507
freerdp_mutex_lock(channels->sync_data_mutex); /* lock channels->sync* vars */
508
509
if (!channels->is_connected)
463
510
{
464
freerdp_mutex_unlock(chan_man->sync_data_mutex);
511
freerdp_mutex_unlock(channels->sync_data_mutex);
465
512
DEBUG_CHANNELS("error not connected");
466
513
return CHANNEL_RC_NOT_CONNECTED;
467
514
}
515
468
516
item = xnew(struct sync_data);
469
517
item->data = pData;
470
518
item->data_length = dataLength;
471
519
item->user_data = pUserData;
472
520
item->index = index;
473
list_enqueue(chan_man->sync_data_list, item);
474
freerdp_mutex_unlock(chan_man->sync_data_mutex);
521
list_enqueue(channels->sync_data_list, item);
522
freerdp_mutex_unlock(channels->sync_data_mutex);
475
523
476
524
/* set the event */
477
wait_obj_set(chan_man->signal);
525
wait_obj_set(channels->signal);
478
526
479
527
return CHANNEL_RC_OK;
480
528
}
481
529
482
530
static uint32 FREERDP_CC MyVirtualChannelEventPush(uint32 openHandle, RDP_EVENT* event)
483
531
{
484
rdpChannels* chan_man;
485
struct channel_data* lchan;
486
532
int index;
487
488
chan_man = freerdp_channels_find_by_open_handle(openHandle, &index);
489
if ((chan_man == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
533
rdpChannels* channels;
534
struct channel_data* lchannel_data;
535
536
channels = freerdp_channels_find_by_open_handle(openHandle, &index);
537
538
if ((channels == NULL) || (index < 0) || (index >= CHANNEL_MAX_COUNT))
490
539
{
491
540
DEBUG_CHANNELS("error bad chanhan");
492
541
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
493
542
}
494
if (!chan_man->is_connected)
543
544
if (!channels->is_connected)
495
545
{
496
546
DEBUG_CHANNELS("error not connected");
497
547
return CHANNEL_RC_NOT_CONNECTED;
498
548
}
549
499
550
if (event == NULL)
500
551
{
501
552
DEBUG_CHANNELS("error bad event");
502
553
return CHANNEL_RC_NULL_DATA;
503
554
}
504
lchan = chan_man->chans + index;
505
if (lchan->flags != 2)
555
556
lchannel_data = channels->channels_data + index;
557
558
if (lchannel_data->flags != 2)
506
559
{
507
560
DEBUG_CHANNELS("error not open");
508
561
return CHANNEL_RC_NOT_OPEN;
509
562
}
510
freerdp_sem_wait(chan_man->event_sem); /* lock channels->event */
511
if (!chan_man->is_connected)
563
564
freerdp_sem_wait(channels->event_sem); /* lock channels->event */
565
566
if (!channels->is_connected)
512
567
{
513
freerdp_sem_signal(chan_man->event_sem);
568
freerdp_sem_signal(channels->event_sem);
514
569
DEBUG_CHANNELS("error not connected");
515
570
return CHANNEL_RC_NOT_CONNECTED;
516
571
}
517
chan_man->event = event;
572
573
channels->event = event;
518
574
/* set the event */
519
wait_obj_set(chan_man->signal);
575
wait_obj_set(channels->signal);
576
520
577
return CHANNEL_RC_OK;
521
578
}
522
579
527
584
*/
528
585
int freerdp_channels_global_init(void)
529
586
{
530
g_init_chan_man = NULL;
587
g_init_channels = NULL;
531
588
g_channels_list = NULL;
532
589
g_open_handle_sequence = 1;
533
590
g_mutex_init = freerdp_mutex_new();
549
606
550
607
rdpChannels* freerdp_channels_new(void)
551
608
{
552
rdpChannels* chan_man;
553
rdpChannelsList* list;
554
555
chan_man = xnew(rdpChannels);
556
557
chan_man->sync_data_mutex = freerdp_mutex_new();
558
chan_man->sync_data_list = list_new();
559
560
chan_man->event_sem = freerdp_sem_new(1);
561
chan_man->signal = wait_obj_new();
609
rdpChannels* channels;
610
rdpChannelsList* channels_list;
611
612
channels = xnew(rdpChannels);
613
614
channels->sync_data_mutex = freerdp_mutex_new();
615
channels->sync_data_list = list_new();
616
617
channels->event_sem = freerdp_sem_new(1);
618
channels->signal = wait_obj_new();
562
619
563
620
/* Add it to the global list */
564
list = xnew(rdpChannelsList);
565
list->channels = chan_man;
621
channels_list = xnew(rdpChannelsList);
622
channels_list->channels = channels;
566
623
567
624
freerdp_mutex_lock(g_mutex_list);
568
list->next = g_channels_list;
569
g_channels_list = list;
625
channels_list->next = g_channels_list;
626
g_channels_list = channels_list;
570
627
freerdp_mutex_unlock(g_mutex_list);
571
628
572
return chan_man;
629
return channels;
573
630
}
574
631
575
void freerdp_channels_free(rdpChannels * chan_man)
632
void freerdp_channels_free(rdpChannels* channels)
576
633
{
577
634
rdpChannelsList* list;
578
635
rdpChannelsList* prev;
579
636
580
freerdp_mutex_free(chan_man->sync_data_mutex);
581
list_free(chan_man->sync_data_list);
637
freerdp_mutex_free(channels->sync_data_mutex);
638
list_free(channels->sync_data_list);
582
639
583
freerdp_sem_free(chan_man->event_sem);
584
wait_obj_free(chan_man->signal);
640
freerdp_sem_free(channels->event_sem);
641
wait_obj_free(channels->signal);
585
642
586
643
/* Remove from global list */
644
587
645
freerdp_mutex_lock(g_mutex_list);
646
588
647
for (prev = NULL, list = g_channels_list; list; prev = list, list = list->next)
589
648
{
590
if (list->channels == chan_man)
649
if (list->channels == channels)
591
650
break;
592
651
}
652
593
653
if (list)
594
654
{
595
655
if (prev)
598
658
g_channels_list = list->next;
599
659
xfree(list);
600
660
}
661
601
662
freerdp_mutex_unlock(g_mutex_list);
602
663
603
xfree(chan_man);
664
xfree(channels);
604
665
}
605
666
606
667
/**
607
668
* this is called when processing the command line parameters
608
669
* called only from main thread
609
670
*/
610
int freerdp_channels_load_plugin(rdpChannels* chan_man, rdpSettings* settings,
611
const char* name, void* data)
671
int freerdp_channels_load_plugin(rdpChannels* channels, rdpSettings* settings, const char* name, void* data)
612
672
{
673
int ok;
613
674
struct lib_data* lib;
614
675
CHANNEL_ENTRY_POINTS_EX ep;
615
int ok;
616
676
617
677
DEBUG_CHANNELS("%s", name);
618
if (chan_man->num_libs + 1 >= CHANNEL_MAX_COUNT)
678
679
if (channels->num_libs_data + 1 >= CHANNEL_MAX_COUNT)
619
680
{
620
681
DEBUG_CHANNELS("too many channels");
621
682
return 1;
622
683
}
623
lib = chan_man->libs + chan_man->num_libs;
624
lib->entry = (PVIRTUALCHANNELENTRY)freerdp_load_plugin(name, CHANNEL_EXPORT_FUNC_NAME);
684
685
lib = channels->libs_data + channels->num_libs_data;
686
lib->entry = (PVIRTUALCHANNELENTRY) freerdp_load_plugin(name, CHANNEL_EXPORT_FUNC_NAME);
687
//lib->entry = (PVIRTUALCHANNELENTRY) freerdp_load_channel_plugin(settings, name, CHANNEL_EXPORT_FUNC_NAME);
688
625
689
if (lib->entry == NULL)
626
690
{
627
691
DEBUG_CHANNELS("failed to find export function");
628
692
return 1;
629
693
}
694
630
695
ep.cbSize = sizeof(ep);
631
696
ep.protocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000;
632
697
ep.pVirtualChannelInit = MyVirtualChannelInit;
637
702
ep.pVirtualChannelEventPush = MyVirtualChannelEventPush;
638
703
639
704
/* enable MyVirtualChannelInit */
640
chan_man->can_call_init = 1;
641
chan_man->settings = settings;
705
channels->can_call_init = 1;
706
channels->settings = settings;
642
707
643
708
freerdp_mutex_lock(g_mutex_init);
644
g_init_chan_man = chan_man;
645
ok = lib->entry((PCHANNEL_ENTRY_POINTS)&ep);
646
g_init_chan_man = NULL;
709
710
g_init_channels = channels;
711
ok = lib->entry((PCHANNEL_ENTRY_POINTS) &ep);
712
g_init_channels = NULL;
713
647
714
freerdp_mutex_unlock(g_mutex_init);
648
715
649
716
/* disable MyVirtualChannelInit */
650
chan_man->settings = 0;
651
chan_man->can_call_init = 0;
717
channels->settings = 0;
718
channels->can_call_init = 0;
719
652
720
if (!ok)
653
721
{
654
722
DEBUG_CHANNELS("export function call failed");
655
723
return 1;
656
724
}
725
657
726
return 0;
658
727
}
659
728
661
730
* go through and inform all the libraries that we are initialized
662
731
* called only from main thread
663
732
*/
664
int freerdp_channels_pre_connect(rdpChannels* chan_man, freerdp* instance)
733
int freerdp_channels_pre_connect(rdpChannels* channels, freerdp* instance)
665
734
{
666
735
int index;
736
void* dummy;
667
737
struct lib_data* llib;
668
738
CHANNEL_DEF lchannel_def;
669
void* dummy;
670
739
671
740
DEBUG_CHANNELS("enter");
672
chan_man->instance = instance;
741
channels->instance = instance;
673
742
674
743
/**
675
744
* If rdpsnd is registered but not rdpdr, it's necessary to register a fake
676
745
* rdpdr channel to make sound work. This is a workaround for Window 7 and
677
746
* Windows 2008
678
747
*/
679
if (freerdp_channels_find_channel_data_by_name(chan_man, "rdpsnd", 0) != 0 &&
680
freerdp_channels_find_channel_data_by_name(chan_man, "rdpdr", 0) == 0)
748
if (freerdp_channels_find_channel_data_by_name(channels, "rdpsnd", 0) != 0 &&
749
freerdp_channels_find_channel_data_by_name(channels, "rdpdr", 0) == 0)
681
750
{
682
751
lchannel_def.options = CHANNEL_OPTION_INITIALIZED |
683
752
CHANNEL_OPTION_ENCRYPT_RDP;
684
753
strcpy(lchannel_def.name, "rdpdr");
685
chan_man->can_call_init = 1;
686
chan_man->settings = instance->settings;
754
channels->can_call_init = 1;
755
channels->settings = instance->settings;
687
756
freerdp_mutex_lock(g_mutex_init);
688
g_init_chan_man = chan_man;
757
g_init_channels = channels;
689
758
MyVirtualChannelInit(&dummy, &lchannel_def, 1,
690
759
VIRTUAL_CHANNEL_VERSION_WIN2000, 0);
691
g_init_chan_man = NULL;
760
g_init_channels = NULL;
692
761
freerdp_mutex_unlock(g_mutex_init);
693
chan_man->can_call_init = 0;
694
chan_man->settings = 0;
762
channels->can_call_init = 0;
763
channels->settings = 0;
695
764
DEBUG_CHANNELS("registered fake rdpdr for rdpsnd.");
696
765
}
697
766
698
for (index = 0; index < chan_man->num_libs; index++)
767
for (index = 0; index < channels->num_libs_data; index++)
699
768
{
700
llib = chan_man->libs + index;
769
llib = channels->libs_data + index;
770
701
771
if (llib->init_event_proc != 0)
702
{
703
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_INITIALIZED,
704
0, 0);
705
}
772
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_INITIALIZED, 0, 0);
706
773
}
774
707
775
return 0;
708
776
}
709
777
712
780
* this will tell the libraries that its ok to call MyVirtualChannelOpen
713
781
* called only from main thread
714
782
*/
715
int freerdp_channels_post_connect(rdpChannels* chan_man, freerdp* instance)
783
int freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
716
784
{
717
785
int index;
718
struct lib_data* llib;
719
786
char* hostname;
720
787
int hostname_len;
788
struct lib_data* llib;
721
789
722
chan_man->is_connected = 1;
790
channels->is_connected = 1;
723
791
hostname = instance->settings->hostname;
724
792
hostname_len = strlen(hostname);
725
DEBUG_CHANNELS("hostname [%s] channels->num_libs [%d]",
726
hostname, channels->num_libs);
727
for (index = 0; index < chan_man->num_libs; index++)
793
794
DEBUG_CHANNELS("hostname [%s] channels->num_libs [%d]", hostname, channels->num_libs_data);
795
796
for (index = 0; index < channels->num_libs_data; index++)
728
797
{
729
llib = chan_man->libs + index;
798
llib = channels->libs_data + index;
799
730
800
if (llib->init_event_proc != 0)
731
{
732
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_CONNECTED,
733
hostname, hostname_len);
734
}
801
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_CONNECTED, hostname, hostname_len);
735
802
}
803
736
804
return 0;
737
805
}
738
806
740
808
* data comming from the server to the client
741
809
* called only from main thread
742
810
*/
743
int freerdp_channels_data(freerdp* instance, int channel_id, void* data, int data_size,
744
int flags, int total_size)
811
int freerdp_channels_data(freerdp* instance, int channel_id, void* data, int data_size, int flags, int total_size)
745
812
{
746
rdpChannels* chan_man;
747
rdpChannel* lrdp_chan;
748
struct channel_data* lchan_data;
749
813
int index;
750
751
chan_man = freerdp_channels_find_by_instance(instance);
752
if (chan_man == 0)
814
rdpChannels* channels;
815
rdpChannel* lrdp_channel;
816
struct channel_data* lchannel_data;
817
818
channels = freerdp_channels_find_by_instance(instance);
819
820
if (channels == 0)
753
821
{
754
822
DEBUG_CHANNELS("could not find channel manager");
755
823
return 1;
756
824
}
757
825
758
lrdp_chan = freerdp_channels_find_channel_by_id(chan_man, instance->settings,
826
lrdp_channel = freerdp_channels_find_channel_by_id(channels, instance->settings,
759
827
channel_id, &index);
760
if (lrdp_chan == 0)
828
if (lrdp_channel == 0)
761
829
{
762
830
DEBUG_CHANNELS("could not find channel id");
763
831
return 1;
764
832
}
765
lchan_data = freerdp_channels_find_channel_data_by_name(chan_man, lrdp_chan->name,
766
&index);
767
if (lchan_data == 0)
833
834
lchannel_data = freerdp_channels_find_channel_data_by_name(channels, lrdp_channel->name, &index);
835
836
if (lchannel_data == 0)
768
837
{
769
838
DEBUG_CHANNELS("could not find channel name");
770
839
return 1;
771
840
}
772
if (lchan_data->open_event_proc != 0)
841
842
if (lchannel_data->open_event_proc != 0)
773
843
{
774
lchan_data->open_event_proc(lchan_data->open_handle,
775
CHANNEL_EVENT_DATA_RECEIVED,
776
data, data_size, total_size, flags);
844
lchannel_data->open_event_proc(lchannel_data->open_handle,
845
CHANNEL_EVENT_DATA_RECEIVED, data, data_size, total_size, flags);
777
846
}
847
778
848
return 0;
779
849
}
780
850
793
863
* @param channels the channel manager instance
794
864
* @param event an event object created by freerdp_event_new()
795
865
*/
796
FREERDP_API int freerdp_channels_send_event(rdpChannels* chan_man, RDP_EVENT* event)
866
FREERDP_API int freerdp_channels_send_event(rdpChannels* channels, RDP_EVENT* event)
797
867
{
798
struct channel_data* lchan_data;
799
868
int index;
800
869
const char* name;
870
struct channel_data* lchannel_data;
801
871
802
872
name = event_class_to_name_table[event->event_class];
873
803
874
if (name == NULL)
804
875
{
805
876
DEBUG_CHANNELS("unknown event_class %d", event->event_class);
807
878
return 1;
808
879
}
809
880
810
lchan_data = freerdp_channels_find_channel_data_by_name(chan_man, name, &index);
811
if (lchan_data == NULL)
881
lchannel_data = freerdp_channels_find_channel_data_by_name(channels, name, &index);
882
883
if (lchannel_data == NULL)
812
884
{
813
885
DEBUG_CHANNELS("could not find channel name %s", name);
814
886
freerdp_event_free(event);
815
887
return 1;
816
888
}
817
if (lchan_data->open_event_proc != NULL)
889
890
if (lchannel_data->open_event_proc != NULL)
818
891
{
819
lchan_data->open_event_proc(lchan_data->open_handle,
892
lchannel_data->open_event_proc(lchannel_data->open_handle,
820
893
CHANNEL_EVENT_USER,
821
894
event, sizeof(RDP_EVENT), sizeof(RDP_EVENT), 0);
822
895
}
896
823
897
return 0;
824
898
}
825
899
826
900
/**
827
901
* called only from main thread
828
902
*/
829
static void freerdp_channels_process_sync(rdpChannels* chan_man, freerdp* instance)
903
static void freerdp_channels_process_sync(rdpChannels* channels, freerdp* instance)
830
904
{
831
rdpChannel* lrdp_chan;
832
905
struct sync_data* item;
833
struct channel_data* lchan_data;
906
rdpChannel* lrdp_channel;
907
struct channel_data* lchannel_data;
834
908
835
while (chan_man->sync_data_list->head != NULL)
909
while (channels->sync_data_list->head != NULL)
836
910
{
837
freerdp_mutex_lock(chan_man->sync_data_mutex);
838
item = (struct sync_data*)list_dequeue(chan_man->sync_data_list);
839
freerdp_mutex_unlock(chan_man->sync_data_mutex);
840
841
lchan_data = chan_man->chans + item->index;
842
lrdp_chan = freerdp_channels_find_channel_by_name(chan_man, instance->settings,
843
lchan_data->name, &item->index);
844
845
if (lrdp_chan != NULL)
846
instance->SendChannelData(instance, lrdp_chan->channel_id, item->data, item->data_length);
847
848
if (lchan_data->open_event_proc != 0)
911
freerdp_mutex_lock(channels->sync_data_mutex);
912
item = (struct sync_data*)list_dequeue(channels->sync_data_list);
913
freerdp_mutex_unlock(channels->sync_data_mutex);
914
915
lchannel_data = channels->channels_data + item->index;
916
lrdp_channel = freerdp_channels_find_channel_by_name(channels, instance->settings,
917
lchannel_data->name, &item->index);
918
919
if (lrdp_channel != NULL)
920
instance->SendChannelData(instance, lrdp_channel->channel_id, item->data, item->data_length);
921
922
if (lchannel_data->open_event_proc != 0)
849
923
{
850
lchan_data->open_event_proc(lchan_data->open_handle,
924
lchannel_data->open_event_proc(lchannel_data->open_handle,
851
925
CHANNEL_EVENT_WRITE_COMPLETE,
852
926
item->user_data, sizeof(void *), sizeof(void *), 0);
853
927
}
858
932
/**
859
933
* called only from main thread
860
934
*/
861
boolean freerdp_channels_get_fds(rdpChannels* chan_man, freerdp* instance, void** read_fds,
935
boolean freerdp_channels_get_fds(rdpChannels* channels, freerdp* instance, void** read_fds,
862
936
int* read_count, void** write_fds, int* write_count)
863
937
{
864
wait_obj_get_fds(chan_man->signal, read_fds, read_count);
938
wait_obj_get_fds(channels->signal, read_fds, read_count);
865
939
return true;
866
940
}
867
941
868
942
/**
869
943
* called only from main thread
870
944
*/
871
boolean freerdp_channels_check_fds(rdpChannels * chan_man, freerdp* instance)
945
boolean freerdp_channels_check_fds(rdpChannels* channels, freerdp* instance)
872
946
{
873
if (wait_obj_is_set(chan_man->signal))
947
if (wait_obj_is_set(channels->signal))
874
948
{
875
wait_obj_clear(chan_man->signal);
876
freerdp_channels_process_sync(chan_man, instance);
949
wait_obj_clear(channels->signal);
950
freerdp_channels_process_sync(channels, instance);
877
951
}
878
952
879
953
return true;
880
954
}
881
955
882
RDP_EVENT* freerdp_channels_pop_event(rdpChannels* chan_man)
956
RDP_EVENT* freerdp_channels_pop_event(rdpChannels* channels)
883
957
{
884
958
RDP_EVENT* event;
885
959
886
if (chan_man->event == NULL)
960
if (channels->event == NULL)
887
961
return NULL;
888
962
889
event = chan_man->event;
890
chan_man->event = NULL;
963
event = channels->event;
964
channels->event = NULL;
891
965
892
freerdp_sem_signal(chan_man->event_sem); /* release channels->event */
966
freerdp_sem_signal(channels->event_sem); /* release channels->event */
893
967
894
968
return event;
895
969
}
896
970
897
void freerdp_channels_close(rdpChannels* chan_man, freerdp* instance)
971
void freerdp_channels_close(rdpChannels* channels, freerdp* instance)
898
972
{
899
973
int index;
900
974
struct lib_data* llib;
901
975
902
976
DEBUG_CHANNELS("closing");
903
chan_man->is_connected = 0;
904
freerdp_channels_check_fds(chan_man, instance);
977
channels->is_connected = 0;
978
freerdp_channels_check_fds(channels, instance);
979
905
980
/* tell all libraries we are shutting down */
906
for (index = 0; index < chan_man->num_libs; index++)
981
for (index = 0; index < channels->num_libs_data; index++)
907
982
{
908
llib = chan_man->libs + index;
983
llib = channels->libs_data + index;
984
909
985
if (llib->init_event_proc != 0)
910
{
911
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_TERMINATED,
912
0, 0);
913
}
986
llib->init_event_proc(llib->init_handle, CHANNEL_EVENT_TERMINATED, 0, 0);
914
987
}
915
988
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1