channels/drdynvc/client/drdynvc_main.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Implementation
   3  * Dynamic Virtual Channel
   4  *
   5  * Copyright 2010-2011 Vic Lee
   6  * Copyright 2015 Thincast Technologies GmbH
   7  * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *     http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <winpr/crt.h>
  27 #include <winpr/stream.h>
  28
  29 #include "drdynvc_main.h"
  30
  31 #define TAG CHANNELS_TAG("drdynvc.client")
  32
  33 static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr);
  34 static void dvcman_channel_free(void* channel);
  35 static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,
  36                                UINT32 dataSize);
  37 static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s);
  38
  39 static void dvcman_wtslistener_free(DVCMAN_LISTENER* listener)
  40 {
  41         if (listener)
  42                 free(listener->channel_name);
  43
  44         free(listener);
  45 }
  46
  47 /**
  48  * Function description
  49  *
  50  * @return 0 on success, otherwise a Win32 error code
  51  */
  52 static UINT dvcman_get_configuration(IWTSListener* pListener, void** ppPropertyBag)
  53 {
  54         WINPR_UNUSED(pListener);
  55         *ppPropertyBag = NULL;
  56         return ERROR_INTERNAL_ERROR;
  57 }
  58
  59 /**
  60  * Function description
  61  *
  62  * @return 0 on success, otherwise a Win32 error code
  63  */
  64 static UINT dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,
  65                                    const char* pszChannelName, ULONG ulFlags,
  66                                    IWTSListenerCallback* pListenerCallback,
  67                                    IWTSListener** ppListener)
  68 {
  69         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
  70         DVCMAN_LISTENER* listener;
  71
  72         WLog_DBG(TAG, "create_listener: %d.%s.", ArrayList_Count(dvcman->listeners) + 1,
  73                  pszChannelName);
  74         listener = (DVCMAN_LISTENER*)calloc(1, sizeof(DVCMAN_LISTENER));
  75
  76         if (!listener)
  77         {
  78                 WLog_ERR(TAG, "calloc failed!");
  79                 return CHANNEL_RC_NO_MEMORY;
  80         }
  81
  82         listener->iface.GetConfiguration = dvcman_get_configuration;
  83         listener->iface.pInterface = NULL;
  84         listener->dvcman = dvcman;
  85         listener->channel_name = _strdup(pszChannelName);
  86
  87         if (!listener->channel_name)
  88         {
  89                 WLog_ERR(TAG, "_strdup failed!");
  90                 dvcman_wtslistener_free(listener);
  91                 return CHANNEL_RC_NO_MEMORY;
  92         }
  93
  94         listener->flags = ulFlags;
  95         listener->listener_callback = pListenerCallback;
  96
  97         if (ppListener)
  98                 *ppListener = (IWTSListener*)listener;
  99
 100         if (ArrayList_Add(dvcman->listeners, listener) < 0)
 101                 return ERROR_INTERNAL_ERROR;
 102         return CHANNEL_RC_OK;
 103 }
 104
 105 static UINT dvcman_destroy_listener(IWTSVirtualChannelManager* pChannelMgr, IWTSListener* pListener)
 106 {
 107         DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)pListener;
 108
 109         WINPR_UNUSED(pChannelMgr);
 110
 111         if (listener)
 112         {
 113                 DVCMAN* dvcman = listener->dvcman;
 114                 if (dvcman)
 115                         ArrayList_Remove(dvcman->listeners, listener);
 116         }
 117
 118         return CHANNEL_RC_OK;
 119 }
 120
 121 /**
 122  * Function description
 123  *
 124  * @return 0 on success, otherwise a Win32 error code
 125  */
 126 static UINT dvcman_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name,
 127                                    IWTSPlugin* pPlugin)
 128 {
 129         DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;
 130
 131         if (ArrayList_Add(dvcman->plugin_names, _strdup(name)) < 0)
 132                 return ERROR_INTERNAL_ERROR;
 133         if (ArrayList_Add(dvcman->plugins, pPlugin) < 0)
 134                 return ERROR_INTERNAL_ERROR;
 135
 136         WLog_DBG(TAG, "register_plugin: num_plugins %d", ArrayList_Count(dvcman->plugins));
 137         return CHANNEL_RC_OK;
 138 }
 139
 140 static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name)
 141 {
 142         IWTSPlugin* plugin = NULL;
 143         size_t i, nc, pc;
 144         DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;
 145         if (!dvcman || !pEntryPoints || !name)
 146                 return NULL;
 147
 148         nc = ArrayList_Count(dvcman->plugin_names);
 149         pc = ArrayList_Count(dvcman->plugins);
 150         if (nc != pc)
 151                 return NULL;
 152
 153         ArrayList_Lock(dvcman->plugin_names);
 154         ArrayList_Lock(dvcman->plugins);
 155         for (i = 0; i < pc; i++)
 156         {
 157                 const char* cur = ArrayList_GetItem(dvcman->plugin_names, i);
 158                 if (strcmp(cur, name) == 0)
 159                 {
 160                         plugin = ArrayList_GetItem(dvcman->plugins, i);
 161                         break;
 162                 }
 163         }
 164         ArrayList_Unlock(dvcman->plugin_names);
 165         ArrayList_Unlock(dvcman->plugins);
 166         return plugin;
 167 }
 168
 169 static ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
 170 {
 171         return ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->args;
 172 }
 173
 174 static void* dvcman_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
 175 {
 176         return (void*)((DVCMAN_ENTRY_POINTS*)pEntryPoints)->settings;
 177 }
 178
 179 static UINT32 dvcman_get_channel_id(IWTSVirtualChannel* channel)
 180 {
 181         DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;
 182         return dvc->channel_id;
 183 }
 184
 185 static const char* dvcman_get_channel_name(IWTSVirtualChannel* channel)
 186 {
 187         DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;
 188         return dvc->channel_name;
 189 }
 190
 191 static IWTSVirtualChannel* dvcman_find_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
 192                                                      UINT32 ChannelId)
 193 {
 194         int index;
 195         IWTSVirtualChannel* channel = NULL;
 196         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
 197         ArrayList_Lock(dvcman->channels);
 198         for (index = 0; index < ArrayList_Count(dvcman->channels); index++)
 199         {
 200                 DVCMAN_CHANNEL* cur = (DVCMAN_CHANNEL*)ArrayList_GetItem(dvcman->channels, index);
 201                 if (cur->channel_id == ChannelId)
 202                 {
 203                         channel = &cur->iface;
 204                         break;
 205                 }
 206         }
 207
 208         ArrayList_Unlock(dvcman->channels);
 209         return channel;
 210 }
 211
 212 static void dvcman_plugin_terminate(void* plugin)
 213 {
 214         IWTSPlugin* pPlugin = plugin;
 215
 216         UINT error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Terminated, pPlugin);
 217         if (error != CHANNEL_RC_OK)
 218                 WLog_ERR(TAG, "Terminated failed with error %" PRIu32 "!", error);
 219 }
 220
 221 static void wts_listener_free(void* arg)
 222 {
 223         DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)arg;
 224         dvcman_wtslistener_free(listener);
 225 }
 226 static IWTSVirtualChannelManager* dvcman_new(drdynvcPlugin* plugin)
 227 {
 228         wObject* obj;
 229         DVCMAN* dvcman;
 230         dvcman = (DVCMAN*)calloc(1, sizeof(DVCMAN));
 231
 232         if (!dvcman)
 233                 return NULL;
 234
 235         dvcman->iface.CreateListener = dvcman_create_listener;
 236         dvcman->iface.DestroyListener = dvcman_destroy_listener;
 237         dvcman->iface.FindChannelById = dvcman_find_channel_by_id;
 238         dvcman->iface.GetChannelId = dvcman_get_channel_id;
 239         dvcman->iface.GetChannelName = dvcman_get_channel_name;
 240         dvcman->drdynvc = plugin;
 241         dvcman->channels = ArrayList_New(TRUE);
 242
 243         if (!dvcman->channels)
 244                 goto fail;
 245
 246         obj = ArrayList_Object(dvcman->channels);
 247         obj->fnObjectFree = dvcman_channel_free;
 248
 249         dvcman->pool = StreamPool_New(TRUE, 10);
 250         if (!dvcman->pool)
 251                 goto fail;
 252
 253         dvcman->listeners = ArrayList_New(TRUE);
 254         if (!dvcman->listeners)
 255                 goto fail;
 256         obj = ArrayList_Object(dvcman->listeners);
 257         obj->fnObjectFree = wts_listener_free;
 258
 259         dvcman->plugin_names = ArrayList_New(TRUE);
 260         if (!dvcman->plugin_names)
 261                 goto fail;
 262         obj = ArrayList_Object(dvcman->plugin_names);
 263         obj->fnObjectFree = free;
 264
 265         dvcman->plugins = ArrayList_New(TRUE);
 266         if (!dvcman->plugins)
 267                 goto fail;
 268         obj = ArrayList_Object(dvcman->plugins);
 269         obj->fnObjectFree = dvcman_plugin_terminate;
 270         return &dvcman->iface;
 271 fail:
 272         dvcman_free(plugin, &dvcman->iface);
 273         return NULL;
 274 }
 275
 276 /**
 277  * Function description
 278  *
 279  * @return 0 on success, otherwise a Win32 error code
 280  */
 281 static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
 282                               ADDIN_ARGV* args, rdpSettings* settings)
 283 {
 284         DVCMAN_ENTRY_POINTS entryPoints;
 285         PDVC_PLUGIN_ENTRY pDVCPluginEntry = NULL;
 286         WLog_Print(drdynvc->log, WLOG_INFO, "Loading Dynamic Virtual Channel %s", args->argv[0]);
 287         pDVCPluginEntry = (PDVC_PLUGIN_ENTRY)freerdp_load_channel_addin_entry(
 288             args->argv[0], NULL, NULL, FREERDP_ADDIN_CHANNEL_DYNAMIC);
 289
 290         if (pDVCPluginEntry)
 291         {
 292                 entryPoints.iface.RegisterPlugin = dvcman_register_plugin;
 293                 entryPoints.iface.GetPlugin = dvcman_get_plugin;
 294                 entryPoints.iface.GetPluginData = dvcman_get_plugin_data;
 295                 entryPoints.iface.GetRdpSettings = dvcman_get_rdp_settings;
 296                 entryPoints.dvcman = (DVCMAN*)pChannelMgr;
 297                 entryPoints.args = args;
 298                 entryPoints.settings = settings;
 299                 return pDVCPluginEntry(&entryPoints.iface);
 300         }
 301
 302         return ERROR_INVALID_FUNCTION;
 303 }
 304
 305 static DVCMAN_CHANNEL* dvcman_channel_new(drdynvcPlugin* drdynvc,
 306                                           IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
 307                                           const char* ChannelName)
 308 {
 309         DVCMAN_CHANNEL* channel;
 310
 311         if (dvcman_find_channel_by_id(pChannelMgr, ChannelId))
 312         {
 313                 WLog_Print(drdynvc->log, WLOG_ERROR,
 314                            "Protocol error: Duplicated ChannelId %" PRIu32 " (%s)!", ChannelId,
 315                            ChannelName);
 316                 return NULL;
 317         }
 318
 319         channel = (DVCMAN_CHANNEL*)calloc(1, sizeof(DVCMAN_CHANNEL));
 320
 321         if (!channel)
 322                 goto fail;
 323
 324         channel->dvcman = (DVCMAN*)pChannelMgr;
 325         channel->channel_id = ChannelId;
 326         channel->channel_name = _strdup(ChannelName);
 327
 328         if (!channel->channel_name)
 329                 goto fail;
 330
 331         if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))
 332                 goto fail;
 333
 334         return channel;
 335 fail:
 336         dvcman_channel_free(channel);
 337         return NULL;
 338 }
 339
 340 static void dvcman_channel_free(void* arg)
 341 {
 342         DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)arg;
 343         UINT error = CHANNEL_RC_OK;
 344
 345         if (channel)
 346         {
 347                 if (channel->channel_callback)
 348                 {
 349                         IFCALL(channel->channel_callback->OnClose, channel->channel_callback);
 350                         channel->channel_callback = NULL;
 351                 }
 352
 353                 if (channel->status == CHANNEL_RC_OK)
 354                 {
 355                         IWTSVirtualChannel* ichannel = (IWTSVirtualChannel*)channel;
 356
 357                         if (channel->dvcman && channel->dvcman->drdynvc)
 358                         {
 359                                 DrdynvcClientContext* context = channel->dvcman->drdynvc->context;
 360
 361                                 if (context)
 362                                 {
 363                                         IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,
 364                                                   channel->pInterface);
 365                                 }
 366                         }
 367
 368                         error = IFCALLRESULT(CHANNEL_RC_OK, ichannel->Close, ichannel);
 369
 370                         if (error != CHANNEL_RC_OK)
 371                                 WLog_ERR(TAG, "Close failed with error %" PRIu32 "!", error);
 372                 }
 373
 374                 if (channel->dvc_data)
 375                         Stream_Release(channel->dvc_data);
 376
 377                 DeleteCriticalSection(&(channel->lock));
 378                 free(channel->channel_name);
 379         }
 380
 381         free(channel);
 382 }
 383
 384 static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
 385 {
 386         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
 387
 388         WINPR_UNUSED(drdynvc);
 389
 390         ArrayList_Clear(dvcman->plugins);
 391         ArrayList_Clear(dvcman->channels);
 392         ArrayList_Clear(dvcman->plugin_names);
 393         ArrayList_Clear(dvcman->listeners);
 394 }
 395
 396 static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
 397 {
 398         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
 399
 400         WINPR_UNUSED(drdynvc);
 401
 402         ArrayList_Free(dvcman->plugins);
 403         ArrayList_Free(dvcman->channels);
 404         ArrayList_Free(dvcman->plugin_names);
 405         ArrayList_Free(dvcman->listeners);
 406
 407         StreamPool_Free(dvcman->pool);
 408         free(dvcman);
 409 }
 410
 411 /**
 412  * Function description
 413  *
 414  * @return 0 on success, otherwise a Win32 error code
 415  */
 416 static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
 417 {
 418         size_t i;
 419         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
 420         UINT error = CHANNEL_RC_OK;
 421
 422         ArrayList_Lock(dvcman->plugins);
 423         for (i = 0; i < ArrayList_Count(dvcman->plugins); i++)
 424         {
 425                 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
 426
 427                 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);
 428                 if (error != CHANNEL_RC_OK)
 429                 {
 430                         WLog_Print(drdynvc->log, WLOG_ERROR, "Initialize failed with error %" PRIu32 "!",
 431                                    error);
 432                         goto fail;
 433                 }
 434         }
 435
 436 fail:
 437         ArrayList_Unlock(dvcman->plugins);
 438         return error;
 439 }
 440
 441 /**
 442  * Function description
 443  *
 444  * @return 0 on success, otherwise a Win32 error code
 445  */
 446 static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize, const BYTE* pBuffer,
 447                                  void* pReserved)
 448 {
 449         UINT status;
 450         DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
 451
 452         WINPR_UNUSED(pReserved);
 453         if (!channel || !channel->dvcman)
 454                 return CHANNEL_RC_BAD_CHANNEL;
 455
 456         EnterCriticalSection(&(channel->lock));
 457         status = drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize);
 458         LeaveCriticalSection(&(channel->lock));
 459         return status;
 460 }
 461
 462 /**
 463  * Function description
 464  *
 465  * @return 0 on success, otherwise a Win32 error code
 466  */
 467 static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)
 468 {
 469         DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
 470
 471         if (!channel)
 472                 return CHANNEL_RC_BAD_CHANNEL;
 473
 474         WLog_DBG(TAG, "close_channel_iface: id=%" PRIu32 "", channel->channel_id);
 475         return CHANNEL_RC_OK;
 476 }
 477
 478 /**
 479  * Function description
 480  *
 481  * @return 0 on success, otherwise a Win32 error code
 482  */
 483 static UINT dvcman_create_channel(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
 484                                   UINT32 ChannelId, const char* ChannelName)
 485 {
 486         size_t i;
 487         BOOL bAccept;
 488         DVCMAN_CHANNEL* channel;
 489         DrdynvcClientContext* context;
 490         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
 491         UINT error;
 492
 493         if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))
 494         {
 495                 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_channel_new failed!");
 496                 return CHANNEL_RC_NO_MEMORY;
 497         }
 498
 499         channel->status = ERROR_NOT_CONNECTED;
 500         if (ArrayList_Add(dvcman->channels, channel) < 0)
 501                 return ERROR_INTERNAL_ERROR;
 502
 503         ArrayList_Lock(dvcman->listeners);
 504         for (i = 0; i < ArrayList_Count(dvcman->listeners); i++)
 505         {
 506                 DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)ArrayList_GetItem(dvcman->listeners, i);
 507
 508                 if (strcmp(listener->channel_name, ChannelName) == 0)
 509                 {
 510                         IWTSVirtualChannelCallback* pCallback = NULL;
 511                         channel->iface.Write = dvcman_write_channel;
 512                         channel->iface.Close = dvcman_close_channel_iface;
 513                         bAccept = TRUE;
 514
 515                         if ((error = listener->listener_callback->OnNewChannelConnection(
 516                                  listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback)) ==
 517                                 CHANNEL_RC_OK &&
 518                             bAccept)
 519                         {
 520                                 WLog_Print(drdynvc->log, WLOG_DEBUG, "listener %s created new channel %" PRIu32 "",
 521                                            listener->channel_name, channel->channel_id);
 522                                 channel->status = CHANNEL_RC_OK;
 523                                 channel->channel_callback = pCallback;
 524                                 channel->pInterface = listener->iface.pInterface;
 525                                 context = dvcman->drdynvc->context;
 526                                 IFCALLRET(context->OnChannelConnected, error, context, ChannelName,
 527                                           listener->iface.pInterface);
 528
 529                                 if (error)
 530                                         WLog_Print(drdynvc->log, WLOG_ERROR,
 531                                                    "context.OnChannelConnected failed with error %" PRIu32 "", error);
 532
 533                                 goto fail;
 534                         }
 535                         else
 536                         {
 537                                 if (error)
 538                                 {
 539                                         WLog_Print(drdynvc->log, WLOG_ERROR,
 540                                                    "OnNewChannelConnection failed with error %" PRIu32 "!", error);
 541                                         goto fail;
 542                                 }
 543                                 else
 544                                 {
 545                                         WLog_Print(drdynvc->log, WLOG_ERROR,
 546                                                    "OnNewChannelConnection returned with bAccept FALSE!");
 547                                         error = ERROR_INTERNAL_ERROR;
 548                                         goto fail;
 549                                 }
 550                         }
 551                 }
 552         }
 553         error = ERROR_INTERNAL_ERROR;
 554 fail:
 555         ArrayList_Unlock(dvcman->listeners);
 556
 557         return error;
 558 }
 559
 560 /**
 561  * Function description
 562  *
 563  * @return 0 on success, otherwise a Win32 error code
 564  */
 565 static UINT dvcman_open_channel(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
 566                                 UINT32 ChannelId)
 567 {
 568         DVCMAN_CHANNEL* channel;
 569         IWTSVirtualChannelCallback* pCallback;
 570         UINT error;
 571         channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);
 572
 573         if (!channel)
 574         {
 575                 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
 576                 return ERROR_INTERNAL_ERROR;
 577         }
 578
 579         if (channel->status == CHANNEL_RC_OK)
 580         {
 581                 pCallback = channel->channel_callback;
 582
 583                 if (pCallback->OnOpen)
 584                 {
 585                         error = pCallback->OnOpen(pCallback);
 586                         if (error)
 587                         {
 588                                 WLog_Print(drdynvc->log, WLOG_ERROR, "OnOpen failed with error %" PRIu32 "!",
 589                                            error);
 590                                 return error;
 591                         }
 592                 }
 593
 594                 WLog_Print(drdynvc->log, WLOG_DEBUG, "open_channel: ChannelId %" PRIu32 "", ChannelId);
 595         }
 596
 597         return CHANNEL_RC_OK;
 598 }
 599
 600 /**
 601  * Function description
 602  *
 603  * @return 0 on success, otherwise a Win32 error code
 604  */
 605 static UINT dvcman_close_channel(IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
 606                                  BOOL bSendClosePDU)
 607 {
 608         DVCMAN_CHANNEL* channel;
 609         UINT error = CHANNEL_RC_OK;
 610         DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
 611         drdynvcPlugin* drdynvc = dvcman->drdynvc;
 612         channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);
 613
 614         if (!channel)
 615         {
 616                 // WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %"PRIu32" not found!", ChannelId);
 617                 /**
 618                  * Windows 8 / Windows Server 2012 send close requests for channels that failed to be
 619                  * created. Do not warn, simply return success here.
 620                  */
 621                 return CHANNEL_RC_OK;
 622         }
 623
 624         if (drdynvc && bSendClosePDU)
 625         {
 626                 wStream* s = StreamPool_Take(dvcman->pool, 5);
 627                 if (!s)
 628                 {
 629                         WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
 630                         error = CHANNEL_RC_NO_MEMORY;
 631                 }
 632                 else
 633                 {
 634                         Stream_Write_UINT8(s, (CLOSE_REQUEST_PDU << 4) | 0x02);
 635                         Stream_Write_UINT32(s, ChannelId);
 636                         error = drdynvc_send(drdynvc, s);
 637                 }
 638         }
 639
 640         ArrayList_Remove(dvcman->channels, channel);
 641         return error;
 642 }
 643
 644 /**
 645  * Function description
 646  *
 647  * @return 0 on success, otherwise a Win32 error code
 648  */
 649 static UINT dvcman_receive_channel_data_first(drdynvcPlugin* drdynvc,
 650                                               IWTSVirtualChannelManager* pChannelMgr,
 651                                               UINT32 ChannelId, UINT32 length)
 652 {
 653         DVCMAN_CHANNEL* channel;
 654         channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);
 655
 656         if (!channel)
 657         {
 658                 /**
 659                  * Windows Server 2012 R2 can send some messages over
 660                  * Microsoft::Windows::RDS::Geometry::v08.01 even if the dynamic virtual channel wasn't
 661                  * registered on our side. Ignoring it works.
 662                  */
 663                 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
 664                 return CHANNEL_RC_OK;
 665         }
 666
 667         if (channel->dvc_data)
 668                 Stream_Release(channel->dvc_data);
 669
 670         channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);
 671
 672         if (!channel->dvc_data)
 673         {
 674                 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
 675                 return CHANNEL_RC_NO_MEMORY;
 676         }
 677
 678         channel->dvc_data_length = length;
 679         return CHANNEL_RC_OK;
 680 }
 681
 682 /**
 683  * Function description
 684  *
 685  * @return 0 on success, otherwise a Win32 error code
 686  */
 687 static UINT dvcman_receive_channel_data(drdynvcPlugin* drdynvc,
 688                                         IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
 689                                         wStream* data)
 690 {
 691         UINT status = CHANNEL_RC_OK;
 692         DVCMAN_CHANNEL* channel;
 693         size_t dataSize = Stream_GetRemainingLength(data);
 694         channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);
 695
 696         if (!channel)
 697         {
 698                 /* Windows 8.1 tries to open channels not created.
 699                  * Ignore cases like this. */
 700                 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
 701                 return CHANNEL_RC_OK;
 702         }
 703
 704         if (channel->dvc_data)
 705         {
 706                 /* Fragmented data */
 707                 if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)
 708                 {
 709                         WLog_Print(drdynvc->log, WLOG_ERROR, "data exceeding declared length!");
 710                         Stream_Release(channel->dvc_data);
 711                         channel->dvc_data = NULL;
 712                         return ERROR_INVALID_DATA;
 713                 }
 714
 715                 Stream_Copy(data, channel->dvc_data, dataSize);
 716
 717                 if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)
 718                 {
 719                         Stream_SealLength(channel->dvc_data);
 720                         Stream_SetPosition(channel->dvc_data, 0);
 721                         status = channel->channel_callback->OnDataReceived(channel->channel_callback,
 722                                                                            channel->dvc_data);
 723                         Stream_Release(channel->dvc_data);
 724                         channel->dvc_data = NULL;
 725                 }
 726         }
 727         else
 728         {
 729                 status = channel->channel_callback->OnDataReceived(channel->channel_callback, data);
 730         }
 731
 732         return status;
 733 }
 734
 735 static UINT8 drdynvc_write_variable_uint(wStream* s, UINT32 val)
 736 {
 737         UINT8 cb;
 738
 739         if (val <= 0xFF)
 740         {
 741                 cb = 0;
 742                 Stream_Write_UINT8(s, (UINT8)val);
 743         }
 744         else if (val <= 0xFFFF)
 745         {
 746                 cb = 1;
 747                 Stream_Write_UINT16(s, (UINT16)val);
 748         }
 749         else
 750         {
 751                 cb = 2;
 752                 Stream_Write_UINT32(s, val);
 753         }
 754
 755         return cb;
 756 }
 757
 758 /**
 759  * Function description
 760  *
 761  * @return 0 on success, otherwise a Win32 error code
 762  */
 763 static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s)
 764 {
 765         UINT status;
 766
 767         if (!drdynvc)
 768                 status = CHANNEL_RC_BAD_CHANNEL_HANDLE;
 769         else
 770         {
 771                 status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(
 772                     drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s),
 773                     (UINT32)Stream_GetPosition(s), s);
 774         }
 775
 776         switch (status)
 777         {
 778                 case CHANNEL_RC_OK:
 779                         return CHANNEL_RC_OK;
 780
 781                 case CHANNEL_RC_NOT_CONNECTED:
 782                         Stream_Release(s);
 783                         return CHANNEL_RC_OK;
 784
 785                 case CHANNEL_RC_BAD_CHANNEL_HANDLE:
 786                         Stream_Release(s);
 787                         WLog_ERR(TAG, "VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");
 788                         return status;
 789
 790                 default:
 791                         Stream_Release(s);
 792                         WLog_Print(drdynvc->log, WLOG_ERROR,
 793                                    "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
 794                                    WTSErrorToString(status), status);
 795                         return status;
 796         }
 797 }
 798
 799 /**
 800  * Function description
 801  *
 802  * @return 0 on success, otherwise a Win32 error code
 803  */
 804 static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,
 805                                UINT32 dataSize)
 806 {
 807         wStream* data_out;
 808         size_t pos;
 809         UINT8 cbChId;
 810         UINT8 cbLen;
 811         unsigned long chunkLength;
 812         UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
 813         DVCMAN* dvcman;
 814
 815         if (!drdynvc)
 816                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
 817
 818         dvcman = (DVCMAN*)drdynvc->channel_mgr;
 819
 820         WLog_Print(drdynvc->log, WLOG_DEBUG, "write_data: ChannelId=%" PRIu32 " size=%" PRIu32 "",
 821                    ChannelId, dataSize);
 822         data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
 823
 824         if (!data_out)
 825         {
 826                 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
 827                 return CHANNEL_RC_NO_MEMORY;
 828         }
 829
 830         Stream_SetPosition(data_out, 1);
 831         cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
 832         pos = Stream_GetPosition(data_out);
 833
 834         if (dataSize == 0)
 835         {
 836                 dvcman_close_channel(drdynvc->channel_mgr, ChannelId, TRUE);
 837                 Stream_Release(data_out);
 838         }
 839         else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)
 840         {
 841                 Stream_SetPosition(data_out, 0);
 842                 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
 843                 Stream_SetPosition(data_out, pos);
 844                 Stream_Write(data_out, data, dataSize);
 845                 status = drdynvc_send(drdynvc, data_out);
 846         }
 847         else
 848         {
 849                 /* Fragment the data */
 850                 cbLen = drdynvc_write_variable_uint(data_out, dataSize);
 851                 pos = Stream_GetPosition(data_out);
 852                 Stream_SetPosition(data_out, 0);
 853                 Stream_Write_UINT8(data_out, (DATA_FIRST_PDU << 4) | cbChId | (cbLen << 2));
 854                 Stream_SetPosition(data_out, pos);
 855                 chunkLength = CHANNEL_CHUNK_LENGTH - pos;
 856                 Stream_Write(data_out, data, chunkLength);
 857                 data += chunkLength;
 858                 dataSize -= chunkLength;
 859                 status = drdynvc_send(drdynvc, data_out);
 860
 861                 while (status == CHANNEL_RC_OK && dataSize > 0)
 862                 {
 863                         data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
 864
 865                         if (!data_out)
 866                         {
 867                                 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
 868                                 return CHANNEL_RC_NO_MEMORY;
 869                         }
 870
 871                         Stream_SetPosition(data_out, 1);
 872                         cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
 873                         pos = Stream_GetPosition(data_out);
 874                         Stream_SetPosition(data_out, 0);
 875                         Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
 876                         Stream_SetPosition(data_out, pos);
 877                         chunkLength = dataSize;
 878
 879                         if (chunkLength > CHANNEL_CHUNK_LENGTH - pos)
 880                                 chunkLength = CHANNEL_CHUNK_LENGTH - pos;
 881
 882                         Stream_Write(data_out, data, chunkLength);
 883                         data += chunkLength;
 884                         dataSize -= chunkLength;
 885                         status = drdynvc_send(drdynvc, data_out);
 886                 }
 887         }
 888
 889         if (status != CHANNEL_RC_OK)
 890         {
 891                 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
 892                            WTSErrorToString(status), status);
 893                 return status;
 894         }
 895
 896         return CHANNEL_RC_OK;
 897 }
 898
 899 /**
 900  * Function description
 901  *
 902  * @return 0 on success, otherwise a Win32 error code
 903  */
 904 static UINT drdynvc_send_capability_response(drdynvcPlugin* drdynvc)
 905 {
 906         UINT status;
 907         wStream* s;
 908         DVCMAN* dvcman;
 909
 910         if (!drdynvc)
 911                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
 912
 913         dvcman = (DVCMAN*)drdynvc->channel_mgr;
 914         WLog_Print(drdynvc->log, WLOG_TRACE, "capability_response");
 915         s = StreamPool_Take(dvcman->pool, 4);
 916
 917         if (!s)
 918         {
 919                 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_Ndrdynvc_write_variable_uintew failed!");
 920                 return CHANNEL_RC_NO_MEMORY;
 921         }
 922
 923         Stream_Write_UINT16(s, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
 924         Stream_Write_UINT16(s, drdynvc->version);
 925         status = drdynvc_send(drdynvc, s);
 926
 927         if (status != CHANNEL_RC_OK)
 928         {
 929                 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
 930                            WTSErrorToString(status), status);
 931         }
 932
 933         return status;
 934 }
 935
 936 /**
 937  * Function description
 938  *
 939  * @return 0 on success, otherwise a Win32 error code
 940  */
 941 static UINT drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId,
 942                                                wStream* s)
 943 {
 944         UINT status;
 945
 946         if (!drdynvc)
 947                 return CHANNEL_RC_BAD_INIT_HANDLE;
 948
 949         if (Stream_GetRemainingLength(s) < 3)
 950                 return ERROR_INVALID_DATA;
 951
 952         WLog_Print(drdynvc->log, WLOG_TRACE, "capability_request Sp=%d cbChId=%d", Sp, cbChId);
 953         Stream_Seek(s, 1); /* pad */
 954         Stream_Read_UINT16(s, drdynvc->version);
 955
 956         /* RDP8 servers offer version 3, though Microsoft forgot to document it
 957          * in their early documents.  It behaves the same as version 2.
 958          */
 959         if ((drdynvc->version == 2) || (drdynvc->version == 3))
 960         {
 961                 if (Stream_GetRemainingLength(s) < 8)
 962                         return ERROR_INVALID_DATA;
 963
 964                 Stream_Read_UINT16(s, drdynvc->PriorityCharge0);
 965                 Stream_Read_UINT16(s, drdynvc->PriorityCharge1);
 966                 Stream_Read_UINT16(s, drdynvc->PriorityCharge2);
 967                 Stream_Read_UINT16(s, drdynvc->PriorityCharge3);
 968         }
 969
 970         status = drdynvc_send_capability_response(drdynvc);
 971         drdynvc->state = DRDYNVC_STATE_READY;
 972         return status;
 973 }
 974
 975 static UINT32 drdynvc_cblen_to_bytes(int cbLen)
 976 {
 977         switch (cbLen)
 978         {
 979                 case 0:
 980                         return 1;
 981
 982                 case 1:
 983                         return 2;
 984
 985                 default:
 986                         return 4;
 987         }
 988 }
 989
 990 static UINT32 drdynvc_read_variable_uint(wStream* s, int cbLen)
 991 {
 992         UINT32 val;
 993
 994         switch (cbLen)
 995         {
 996                 case 0:
 997                         Stream_Read_UINT8(s, val);
 998                         break;
 999
1000                 case 1:
1001                         Stream_Read_UINT16(s, val);
1002                         break;
1003
1004                 default:
1005                         Stream_Read_UINT32(s, val);
1006                         break;
1007         }
1008
1009         return val;
1010 }
1011
1012 /**
1013  * Function description
1014  *
1015  * @return 0 on success, otherwise a Win32 error code
1016  */
1017 static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1018 {
1019         size_t pos;
1020         UINT status;
1021         UINT32 ChannelId;
1022         wStream* data_out;
1023         UINT channel_status;
1024         char* name;
1025         size_t length;
1026         DVCMAN* dvcman;
1027
1028         WINPR_UNUSED(Sp);
1029         if (!drdynvc)
1030                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1031
1032         dvcman = (DVCMAN*)drdynvc->channel_mgr;
1033         if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)
1034         {
1035                 /**
1036                  * For some reason the server does not always send the
1037                  * capabilities pdu as it should. When this happens,
1038                  * send a capabilities response.
1039                  */
1040                 drdynvc->version = 3;
1041
1042                 if ((status = drdynvc_send_capability_response(drdynvc)))
1043                 {
1044                         WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_send_capability_response failed!");
1045                         return status;
1046                 }
1047
1048                 drdynvc->state = DRDYNVC_STATE_READY;
1049         }
1050
1051         if (Stream_GetRemainingLength(s) < drdynvc_cblen_to_bytes(cbChId))
1052                 return ERROR_INVALID_DATA;
1053
1054         ChannelId = drdynvc_read_variable_uint(s, cbChId);
1055         pos = Stream_GetPosition(s);
1056         name = (char*)Stream_Pointer(s);
1057         length = Stream_GetRemainingLength(s);
1058
1059         if (strnlen(name, length) >= length)
1060                 return ERROR_INVALID_DATA;
1061
1062         WLog_Print(drdynvc->log, WLOG_DEBUG,
1063                    "process_create_request: ChannelId=%" PRIu32 " ChannelName=%s", ChannelId, name);
1064         channel_status = dvcman_create_channel(drdynvc, drdynvc->channel_mgr, ChannelId, name);
1065         data_out = StreamPool_Take(dvcman->pool, pos + 4);
1066
1067         if (!data_out)
1068         {
1069                 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1070                 return CHANNEL_RC_NO_MEMORY;
1071         }
1072
1073         Stream_Write_UINT8(data_out, (CREATE_REQUEST_PDU << 4) | cbChId);
1074         Stream_SetPosition(s, 1);
1075         Stream_Copy(s, data_out, pos - 1);
1076
1077         if (channel_status == CHANNEL_RC_OK)
1078         {
1079                 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel created");
1080                 Stream_Write_UINT32(data_out, 0);
1081         }
1082         else
1083         {
1084                 WLog_Print(drdynvc->log, WLOG_DEBUG, "no listener");
1085                 Stream_Write_UINT32(data_out, (UINT32)0xC0000001); /* same code used by mstsc */
1086         }
1087
1088         status = drdynvc_send(drdynvc, data_out);
1089
1090         if (status != CHANNEL_RC_OK)
1091         {
1092                 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1093                            WTSErrorToString(status), status);
1094                 return status;
1095         }
1096
1097         if (channel_status == CHANNEL_RC_OK)
1098         {
1099                 if ((status = dvcman_open_channel(drdynvc, drdynvc->channel_mgr, ChannelId)))
1100                 {
1101                         WLog_Print(drdynvc->log, WLOG_ERROR,
1102                                    "dvcman_open_channel failed with error %" PRIu32 "!", status);
1103                         return status;
1104                 }
1105         }
1106         else
1107         {
1108                 if ((status = dvcman_close_channel(drdynvc->channel_mgr, ChannelId, FALSE)))
1109                         WLog_Print(drdynvc->log, WLOG_ERROR,
1110                                    "dvcman_close_channel failed with error %" PRIu32 "!", status);
1111         }
1112
1113         return status;
1114 }
1115
1116 /**
1117  * Function description
1118  *
1119  * @return 0 on success, otherwise a Win32 error code
1120  */
1121 static UINT drdynvc_process_data_first(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1122 {
1123         UINT status;
1124         UINT32 Length;
1125         UINT32 ChannelId;
1126
1127         if (Stream_GetRemainingLength(s) < drdynvc_cblen_to_bytes(cbChId) + drdynvc_cblen_to_bytes(Sp))
1128                 return ERROR_INVALID_DATA;
1129
1130         ChannelId = drdynvc_read_variable_uint(s, cbChId);
1131         Length = drdynvc_read_variable_uint(s, Sp);
1132         WLog_Print(drdynvc->log, WLOG_DEBUG,
1133                    "process_data_first: Sp=%d cbChId=%d, ChannelId=%" PRIu32 " Length=%" PRIu32 "", Sp,
1134                    cbChId, ChannelId, Length);
1135         status = dvcman_receive_channel_data_first(drdynvc, drdynvc->channel_mgr, ChannelId, Length);
1136
1137         if (status == CHANNEL_RC_OK)
1138                 status = dvcman_receive_channel_data(drdynvc, drdynvc->channel_mgr, ChannelId, s);
1139
1140         if (status != CHANNEL_RC_OK)
1141                 status = dvcman_close_channel(drdynvc->channel_mgr, ChannelId, TRUE);
1142
1143         return status;
1144 }
1145
1146 /**
1147  * Function description
1148  *
1149  * @return 0 on success, otherwise a Win32 error code
1150  */
1151 static UINT drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1152 {
1153         UINT32 ChannelId;
1154         UINT status;
1155
1156         if (Stream_GetRemainingLength(s) < drdynvc_cblen_to_bytes(cbChId))
1157                 return ERROR_INVALID_DATA;
1158
1159         ChannelId = drdynvc_read_variable_uint(s, cbChId);
1160         WLog_Print(drdynvc->log, WLOG_TRACE, "process_data: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp,
1161                    cbChId, ChannelId);
1162         status = dvcman_receive_channel_data(drdynvc, drdynvc->channel_mgr, ChannelId, s);
1163
1164         if (status != CHANNEL_RC_OK)
1165                 status = dvcman_close_channel(drdynvc->channel_mgr, ChannelId, TRUE);
1166
1167         return status;
1168 }
1169
1170 /**
1171  * Function description
1172  *
1173  * @return 0 on success, otherwise a Win32 error code
1174  */
1175 static UINT drdynvc_process_close_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1176 {
1177         UINT error;
1178         UINT32 ChannelId;
1179
1180         if (Stream_GetRemainingLength(s) < drdynvc_cblen_to_bytes(cbChId))
1181                 return ERROR_INVALID_DATA;
1182
1183         ChannelId = drdynvc_read_variable_uint(s, cbChId);
1184         WLog_Print(drdynvc->log, WLOG_DEBUG,
1185                    "process_close_request: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp, cbChId,
1186                    ChannelId);
1187
1188         if ((error = dvcman_close_channel(drdynvc->channel_mgr, ChannelId, TRUE)))
1189                 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_close_channel failed with error %" PRIu32 "!",
1190                            error);
1191
1192         return error;
1193 }
1194
1195 /**
1196  * Function description
1197  *
1198  * @return 0 on success, otherwise a Win32 error code
1199  */
1200 static UINT drdynvc_order_recv(drdynvcPlugin* drdynvc, wStream* s)
1201 {
1202         int value;
1203         int Cmd;
1204         int Sp;
1205         int cbChId;
1206
1207         if (Stream_GetRemainingLength(s) < 1)
1208                 return ERROR_INVALID_DATA;
1209
1210         Stream_Read_UINT8(s, value);
1211         Cmd = (value & 0xf0) >> 4;
1212         Sp = (value & 0x0c) >> 2;
1213         cbChId = (value & 0x03) >> 0;
1214         WLog_Print(drdynvc->log, WLOG_DEBUG, "order_recv: Cmd=0x%x, Sp=%d cbChId=%d", Cmd, Sp, cbChId);
1215
1216         switch (Cmd)
1217         {
1218                 case CAPABILITY_REQUEST_PDU:
1219                         return drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
1220
1221                 case CREATE_REQUEST_PDU:
1222                         return drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
1223
1224                 case DATA_FIRST_PDU:
1225                         return drdynvc_process_data_first(drdynvc, Sp, cbChId, s);
1226
1227                 case DATA_PDU:
1228                         return drdynvc_process_data(drdynvc, Sp, cbChId, s);
1229
1230                 case CLOSE_REQUEST_PDU:
1231                         return drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
1232
1233                 default:
1234                         WLog_Print(drdynvc->log, WLOG_ERROR, "unknown drdynvc cmd 0x%x", Cmd);
1235                         return ERROR_INTERNAL_ERROR;
1236         }
1237 }
1238
1239 /**
1240  * Function description
1241  *
1242  * @return 0 on success, otherwise a Win32 error code
1243  */
1244 static UINT drdynvc_virtual_channel_event_data_received(drdynvcPlugin* drdynvc, void* pData,
1245                                                         UINT32 dataLength, UINT32 totalLength,
1246                                                         UINT32 dataFlags)
1247 {
1248         wStream* data_in;
1249
1250         if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1251         {
1252                 return CHANNEL_RC_OK;
1253         }
1254
1255         if (dataFlags & CHANNEL_FLAG_FIRST)
1256         {
1257                 DVCMAN* mgr = (DVCMAN*)drdynvc->channel_mgr;
1258                 if (drdynvc->data_in)
1259                         Stream_Release(drdynvc->data_in);
1260
1261                 drdynvc->data_in = StreamPool_Take(mgr->pool, totalLength);
1262         }
1263
1264         if (!(data_in = drdynvc->data_in))
1265         {
1266                 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1267                 return CHANNEL_RC_NO_MEMORY;
1268         }
1269
1270         if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1271         {
1272                 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
1273                 Stream_Release(drdynvc->data_in);
1274                 drdynvc->data_in = NULL;
1275                 return ERROR_INTERNAL_ERROR;
1276         }
1277
1278         Stream_Write(data_in, pData, dataLength);
1279
1280         if (dataFlags & CHANNEL_FLAG_LAST)
1281         {
1282                 const size_t cap = Stream_Capacity(data_in);
1283                 const size_t pos = Stream_GetPosition(data_in);
1284                 if (cap < pos)
1285                 {
1286                         WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_plugin_process_received: read error");
1287                         return ERROR_INVALID_DATA;
1288                 }
1289
1290                 drdynvc->data_in = NULL;
1291                 Stream_SealLength(data_in);
1292                 Stream_SetPosition(data_in, 0);
1293
1294                 if (!MessageQueue_Post(drdynvc->queue, NULL, 0, (void*)data_in, NULL))
1295                 {
1296                         WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Post failed!");
1297                         return ERROR_INTERNAL_ERROR;
1298                 }
1299         }
1300
1301         return CHANNEL_RC_OK;
1302 }
1303
1304 static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1305                                                             UINT event, LPVOID pData,
1306                                                             UINT32 dataLength, UINT32 totalLength,
1307                                                             UINT32 dataFlags)
1308 {
1309         UINT error = CHANNEL_RC_OK;
1310         drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1311
1312         switch (event)
1313         {
1314                 case CHANNEL_EVENT_DATA_RECEIVED:
1315                         if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1316                         {
1317                                 WLog_ERR(TAG, "drdynvc_virtual_channel_open_event: error no match");
1318                                 return;
1319                         }
1320                         if ((error = drdynvc_virtual_channel_event_data_received(drdynvc, pData, dataLength,
1321                                                                                  totalLength, dataFlags)))
1322                                 WLog_Print(drdynvc->log, WLOG_ERROR,
1323                                            "drdynvc_virtual_channel_event_data_received failed with error %" PRIu32
1324                                            "",
1325                                            error);
1326
1327                         break;
1328
1329                 case CHANNEL_EVENT_WRITE_CANCELLED:
1330                 case CHANNEL_EVENT_WRITE_COMPLETE:
1331                 {
1332                         wStream* s = (wStream*)pData;
1333                         Stream_Release(s);
1334                 }
1335                 break;
1336
1337                 case CHANNEL_EVENT_USER:
1338                         break;
1339         }
1340
1341         if (error && drdynvc && drdynvc->rdpcontext)
1342                 setChannelError(drdynvc->rdpcontext, error,
1343                                 "drdynvc_virtual_channel_open_event reported an error");
1344 }
1345
1346 static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1347 {
1348         wStream* data;
1349         wMessage message;
1350         UINT error = CHANNEL_RC_OK;
1351         drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1352
1353         if (!drdynvc)
1354         {
1355                 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1356                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1357         }
1358
1359         while (1)
1360         {
1361                 if (!MessageQueue_Wait(drdynvc->queue))
1362                 {
1363                         WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Wait failed!");
1364                         error = ERROR_INTERNAL_ERROR;
1365                         break;
1366                 }
1367
1368                 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1369                 {
1370                         WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Peek failed!");
1371                         error = ERROR_INTERNAL_ERROR;
1372                         break;
1373                 }
1374
1375                 if (message.id == WMQ_QUIT)
1376                         break;
1377
1378                 if (message.id == 0)
1379                 {
1380                         data = (wStream*)message.wParam;
1381
1382                         if ((error = drdynvc_order_recv(drdynvc, data)))
1383                         {
1384                                 WLog_Print(drdynvc->log, WLOG_WARN,
1385                                            "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1386                         }
1387
1388                         Stream_Release(data);
1389                 }
1390         }
1391
1392         {
1393                 /* Disconnect remaining dynamic channels that the server did not.
1394                  * This is required to properly shut down channels by calling the appropriate
1395                  * event handlers. */
1396                 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1397
1398                 while (ArrayList_Count(drdynvcMgr->channels) > 0)
1399                 {
1400                         IWTSVirtualChannel* channel =
1401                             (IWTSVirtualChannel*)ArrayList_GetItem(drdynvcMgr->channels, 0);
1402                         const UINT32 ChannelId = drdynvc->channel_mgr->GetChannelId(channel);
1403                         dvcman_close_channel(drdynvc->channel_mgr, ChannelId, FALSE);
1404                 }
1405         }
1406
1407         if (error && drdynvc->rdpcontext)
1408                 setChannelError(drdynvc->rdpcontext, error,
1409                                 "drdynvc_virtual_channel_client_thread reported an error");
1410
1411         ExitThread((DWORD)error);
1412         return error;
1413 }
1414
1415 static void drdynvc_queue_object_free(void* obj)
1416 {
1417         wStream* s;
1418         wMessage* msg = (wMessage*)obj;
1419
1420         if (!msg || (msg->id != 0))
1421                 return;
1422
1423         s = (wStream*)msg->wParam;
1424
1425         if (s)
1426                 Stream_Release(s);
1427 }
1428
1429 static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1430                                                       UINT32 dataLength)
1431 {
1432         UINT error = CHANNEL_RC_OK;
1433         WINPR_UNUSED(pData);
1434         WINPR_UNUSED(dataLength);
1435
1436         if (!drdynvc)
1437                 goto error;
1438
1439         drdynvc->queue = MessageQueue_New(NULL);
1440
1441         if (!drdynvc->queue)
1442         {
1443                 error = CHANNEL_RC_NO_MEMORY;
1444                 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_New failed!");
1445                 goto error;
1446         }
1447
1448         drdynvc->queue->object.fnObjectFree = drdynvc_queue_object_free;
1449         drdynvc->channel_mgr = dvcman_new(drdynvc);
1450
1451         if (!drdynvc->channel_mgr)
1452         {
1453                 error = CHANNEL_RC_NO_MEMORY;
1454                 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_new failed!");
1455                 goto error;
1456         }
1457
1458         return CHANNEL_RC_OK;
1459 error:
1460         return ERROR_INTERNAL_ERROR;
1461 }
1462
1463 /**
1464  * Function description
1465  *
1466  * @return 0 on success, otherwise a Win32 error code
1467  */
1468 static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1469                                                     UINT32 dataLength)
1470 {
1471         UINT error;
1472         UINT32 status;
1473         UINT32 index;
1474         ADDIN_ARGV* args;
1475         rdpSettings* settings;
1476
1477         WINPR_UNUSED(pData);
1478         WINPR_UNUSED(dataLength);
1479
1480         if (!drdynvc)
1481                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1482
1483         status = drdynvc->channelEntryPoints.pVirtualChannelOpenEx(
1484             drdynvc->InitHandle, &drdynvc->OpenHandle, drdynvc->channelDef.name,
1485             drdynvc_virtual_channel_open_event_ex);
1486
1487         if (status != CHANNEL_RC_OK)
1488         {
1489                 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelOpen failed with %s [%08" PRIX32 "]",
1490                            WTSErrorToString(status), status);
1491                 return status;
1492         }
1493
1494         settings = (rdpSettings*)drdynvc->channelEntryPoints.pExtendedData;
1495
1496         for (index = 0; index < settings->DynamicChannelCount; index++)
1497         {
1498                 args = settings->DynamicChannelArray[index];
1499                 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, settings);
1500
1501                 if (CHANNEL_RC_OK != error)
1502                         goto error;
1503         }
1504
1505         if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1506         {
1507                 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_init failed with error %" PRIu32 "!", error);
1508                 goto error;
1509         }
1510
1511         drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1512
1513         if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1514                                              (void*)drdynvc, 0, NULL)))
1515         {
1516                 error = ERROR_INTERNAL_ERROR;
1517                 WLog_Print(drdynvc->log, WLOG_ERROR, "CreateThread failed!");
1518                 goto error;
1519         }
1520
1521 error:
1522         return error;
1523 }
1524
1525 /**
1526  * Function description
1527  *
1528  * @return 0 on success, otherwise a Win32 error code
1529  */
1530 static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1531 {
1532         UINT status;
1533
1534         if (!drdynvc)
1535                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1536
1537         if (drdynvc->OpenHandle == 0)
1538                 return CHANNEL_RC_OK;
1539
1540         if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1541         {
1542                 status = GetLastError();
1543                 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_PostQuit failed with error %" PRIu32 "",
1544                            status);
1545                 return status;
1546         }
1547
1548         if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1549         {
1550                 status = GetLastError();
1551                 WLog_Print(drdynvc->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "",
1552                            status);
1553                 return status;
1554         }
1555
1556         CloseHandle(drdynvc->thread);
1557         drdynvc->thread = NULL;
1558
1559         status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1560                                                                     drdynvc->OpenHandle);
1561
1562         if (status != CHANNEL_RC_OK)
1563         {
1564                 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelClose failed with %s [%08" PRIX32 "]",
1565                            WTSErrorToString(status), status);
1566         }
1567
1568         dvcman_clear(drdynvc, drdynvc->channel_mgr);
1569         MessageQueue_Clear(drdynvc->queue);
1570         drdynvc->OpenHandle = 0;
1571
1572         if (drdynvc->data_in)
1573         {
1574                 Stream_Release(drdynvc->data_in);
1575                 drdynvc->data_in = NULL;
1576         }
1577
1578         return status;
1579 }
1580
1581 /**
1582  * Function description
1583  *
1584  * @return 0 on success, otherwise a Win32 error code
1585  */
1586 static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1587 {
1588         if (!drdynvc)
1589                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1590
1591         MessageQueue_Free(drdynvc->queue);
1592         drdynvc->queue = NULL;
1593
1594         if (drdynvc->channel_mgr)
1595         {
1596                 dvcman_free(drdynvc, drdynvc->channel_mgr);
1597                 drdynvc->channel_mgr = NULL;
1598         }
1599
1600         drdynvc->InitHandle = 0;
1601         free(drdynvc->context);
1602         free(drdynvc);
1603         return CHANNEL_RC_OK;
1604 }
1605
1606 static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1607 {
1608         UINT error = CHANNEL_RC_OK;
1609         size_t i;
1610         DVCMAN* dvcman;
1611
1612         if (!drdynvc)
1613                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1614
1615         dvcman = (DVCMAN*)drdynvc->channel_mgr;
1616
1617         if (!dvcman)
1618                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1619
1620         ArrayList_Lock(dvcman->plugins);
1621         for (i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1622         {
1623                 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1624
1625                 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1626                 if (error != CHANNEL_RC_OK)
1627                 {
1628                         WLog_Print(drdynvc->log, WLOG_ERROR, "Attach failed with error %" PRIu32 "!", error);
1629                         goto fail;
1630                 }
1631         }
1632
1633 fail:
1634         ArrayList_Unlock(dvcman->plugins);
1635         return error;
1636 }
1637
1638 static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1639 {
1640         UINT error = CHANNEL_RC_OK;
1641         size_t i;
1642         DVCMAN* dvcman;
1643
1644         if (!drdynvc)
1645                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1646
1647         dvcman = (DVCMAN*)drdynvc->channel_mgr;
1648
1649         if (!dvcman)
1650                 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1651
1652         ArrayList_Lock(dvcman->plugins);
1653         for (i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1654         {
1655                 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1656
1657                 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1658                 if (error != CHANNEL_RC_OK)
1659                 {
1660                         WLog_Print(drdynvc->log, WLOG_ERROR, "Detach failed with error %" PRIu32 "!", error);
1661                         goto fail;
1662                 }
1663         }
1664
1665 fail:
1666         ArrayList_Unlock(dvcman->plugins);
1667
1668         return error;
1669 }
1670
1671 static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1672                                                             UINT event, LPVOID pData,
1673                                                             UINT dataLength)
1674 {
1675         UINT error = CHANNEL_RC_OK;
1676         drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1677
1678         if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
1679         {
1680                 WLog_ERR(TAG, "drdynvc_virtual_channel_init_event: error no match");
1681                 return;
1682         }
1683
1684         switch (event)
1685         {
1686                 case CHANNEL_EVENT_INITIALIZED:
1687                         error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
1688                         break;
1689                 case CHANNEL_EVENT_CONNECTED:
1690                         if ((error = drdynvc_virtual_channel_event_connected(drdynvc, pData, dataLength)))
1691                                 WLog_Print(drdynvc->log, WLOG_ERROR,
1692                                            "drdynvc_virtual_channel_event_connected failed with error %" PRIu32 "",
1693                                            error);
1694
1695                         break;
1696
1697                 case CHANNEL_EVENT_DISCONNECTED:
1698                         if ((error = drdynvc_virtual_channel_event_disconnected(drdynvc)))
1699                                 WLog_Print(drdynvc->log, WLOG_ERROR,
1700                                            "drdynvc_virtual_channel_event_disconnected failed with error %" PRIu32
1701                                            "",
1702                                            error);
1703
1704                         break;
1705
1706                 case CHANNEL_EVENT_TERMINATED:
1707                         if ((error = drdynvc_virtual_channel_event_terminated(drdynvc)))
1708                                 WLog_Print(drdynvc->log, WLOG_ERROR,
1709                                            "drdynvc_virtual_channel_event_terminated failed with error %" PRIu32 "",
1710                                            error);
1711
1712                         break;
1713
1714                 case CHANNEL_EVENT_ATTACHED:
1715                         if ((error = drdynvc_virtual_channel_event_attached(drdynvc)))
1716                                 WLog_Print(drdynvc->log, WLOG_ERROR,
1717                                            "drdynvc_virtual_channel_event_attached failed with error %" PRIu32 "",
1718                                            error);
1719
1720                         break;
1721
1722                 case CHANNEL_EVENT_DETACHED:
1723                         if ((error = drdynvc_virtual_channel_event_detached(drdynvc)))
1724                                 WLog_Print(drdynvc->log, WLOG_ERROR,
1725                                            "drdynvc_virtual_channel_event_detached failed with error %" PRIu32 "",
1726                                            error);
1727
1728                         break;
1729
1730                 default:
1731                         break;
1732         }
1733
1734         if (error && drdynvc->rdpcontext)
1735                 setChannelError(drdynvc->rdpcontext, error,
1736                                 "drdynvc_virtual_channel_init_event_ex reported an error");
1737 }
1738
1739 /**
1740  * Channel Client Interface
1741  */
1742
1743 static int drdynvc_get_version(DrdynvcClientContext* context)
1744 {
1745         drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
1746         return drdynvc->version;
1747 }
1748
1749 /* drdynvc is always built-in */
1750 #define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
1751
1752 BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints, PVOID pInitHandle)
1753 {
1754         UINT rc;
1755         drdynvcPlugin* drdynvc;
1756         DrdynvcClientContext* context = NULL;
1757         CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx;
1758         drdynvc = (drdynvcPlugin*)calloc(1, sizeof(drdynvcPlugin));
1759
1760         if (!drdynvc)
1761         {
1762                 WLog_ERR(TAG, "calloc failed!");
1763                 return FALSE;
1764         }
1765
1766         drdynvc->channelDef.options =
1767             CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
1768         sprintf_s(drdynvc->channelDef.name, ARRAYSIZE(drdynvc->channelDef.name), "drdynvc");
1769         drdynvc->state = DRDYNVC_STATE_INITIAL;
1770         pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
1771
1772         if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
1773             (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
1774         {
1775                 context = (DrdynvcClientContext*)calloc(1, sizeof(DrdynvcClientContext));
1776
1777                 if (!context)
1778                 {
1779                         WLog_Print(drdynvc->log, WLOG_ERROR, "calloc failed!");
1780                         free(drdynvc);
1781                         return FALSE;
1782                 }
1783
1784                 context->handle = (void*)drdynvc;
1785                 context->custom = NULL;
1786                 drdynvc->context = context;
1787                 context->GetVersion = drdynvc_get_version;
1788                 drdynvc->rdpcontext = pEntryPointsEx->context;
1789         }
1790
1791         drdynvc->log = WLog_Get(TAG);
1792         WLog_Print(drdynvc->log, WLOG_DEBUG, "VirtualChannelEntryEx");
1793         CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
1794                    sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
1795         drdynvc->InitHandle = pInitHandle;
1796         rc = drdynvc->channelEntryPoints.pVirtualChannelInitEx(
1797             drdynvc, context, pInitHandle, &drdynvc->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
1798             drdynvc_virtual_channel_init_event_ex);
1799
1800         if (CHANNEL_RC_OK != rc)
1801         {
1802                 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelInit failed with %s [%08" PRIX32 "]",
1803                            WTSErrorToString(rc), rc);
1804                 free(drdynvc->context);
1805                 free(drdynvc);
1806                 return FALSE;
1807         }
1808
1809         drdynvc->channelEntryPoints.pInterface = context;
1810         return TRUE;
1811 }