channels/rdpdr/rdpdr_main.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol client.
   3  * File System Virtual Channel
   4  *
   5  * Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
   6  * Copyright 2010-2011 Vic Lee
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <freerdp/constants.h>
  26 #include <freerdp/types.h>
  27 #include <freerdp/utils/memory.h>
  28 #include <freerdp/utils/stream.h>
  29 #include <freerdp/utils/unicode.h>
  30 #include <freerdp/utils/svc_plugin.h>
  31
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35
  36 #include "rdpdr_types.h"
  37 #include "rdpdr_constants.h"
  38 #include "rdpdr_capabilities.h"
  39 #include "devman.h"
  40 #include "irp.h"
  41 #include "rdpdr_main.h"
  42
  43 static void rdpdr_process_connect(rdpSvcPlugin* plugin)
  44 {
  45         rdpdrPlugin* rdpdr = (rdpdrPlugin*) plugin;
  46         RDP_PLUGIN_DATA* data;
  47
  48         rdpdr->devman = devman_new(plugin);
  49         data = (RDP_PLUGIN_DATA*) plugin->channel_entry_points.pExtendedData;
  50
  51         while (data && data->size > 0)
  52         {
  53                 if (strcmp((char*) data->data[0], "clientname") == 0)
  54                 {
  55                         strncpy(rdpdr->computerName, (char*) data->data[1], sizeof(rdpdr->computerName) - 1);
  56                         DEBUG_SVC("computerName %s", rdpdr->computerName);
  57                 }
  58                 else
  59                 {
  60                         devman_load_device_service(rdpdr->devman, data);
  61                 }
  62                 data = (RDP_PLUGIN_DATA*) (((void*) data) + data->size);
  63         }
  64 }
  65
  66 static void rdpdr_process_server_announce_request(rdpdrPlugin* rdpdr, STREAM* data_in)
  67 {
  68         stream_read_uint16(data_in, rdpdr->versionMajor);
  69         stream_read_uint16(data_in, rdpdr->versionMinor);
  70         stream_read_uint32(data_in, rdpdr->clientID);
  71
  72         DEBUG_SVC("version %d.%d clientID %d", rdpdr->versionMajor, rdpdr->versionMinor, rdpdr->clientID);
  73 }
  74
  75 static void rdpdr_send_client_announce_reply(rdpdrPlugin* rdpdr)
  76 {
  77         STREAM* data_out;
  78
  79         data_out = stream_new(12);
  80
  81         stream_write_uint16(data_out, RDPDR_CTYP_CORE);
  82         stream_write_uint16(data_out, PAKID_CORE_CLIENTID_CONFIRM);
  83
  84         stream_write_uint16(data_out, rdpdr->versionMajor);
  85         stream_write_uint16(data_out, rdpdr->versionMinor);
  86         stream_write_uint32(data_out, rdpdr->clientID);
  87
  88         svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
  89 }
  90
  91 static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr)
  92 {
  93         char* s;
  94         STREAM* data_out;
  95         UNICONV* uniconv;
  96         size_t computerNameLenW;
  97
  98         uniconv = freerdp_uniconv_new();
  99
 100         if (!rdpdr->computerName[0])
 101                 gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);
 102
 103         s = freerdp_uniconv_out(uniconv, rdpdr->computerName, &computerNameLenW);
 104         data_out = stream_new(16 + computerNameLenW + 2);
 105
 106         stream_write_uint16(data_out, RDPDR_CTYP_CORE);
 107         stream_write_uint16(data_out, PAKID_CORE_CLIENT_NAME);
 108
 109         stream_write_uint32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */
 110         stream_write_uint32(data_out, 0); /* codePage, must be set to zero */
 111         stream_write_uint32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */
 112         stream_write(data_out, s, computerNameLenW);
 113         stream_write_uint16(data_out, 0); /* null terminator */
 114
 115         xfree(s);
 116         freerdp_uniconv_free(uniconv);
 117
 118         svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
 119 }
 120
 121 static void rdpdr_process_server_clientid_confirm(rdpdrPlugin* rdpdr, STREAM* data_in)
 122 {
 123         uint16 versionMajor;
 124         uint16 versionMinor;
 125         uint32 clientID;
 126
 127         stream_read_uint16(data_in, versionMajor);
 128         stream_read_uint16(data_in, versionMinor);
 129         stream_read_uint32(data_in, clientID);
 130
 131         if (versionMajor != rdpdr->versionMajor || versionMinor != rdpdr->versionMinor)
 132         {
 133                 DEBUG_WARN("unmatched version %d.%d", versionMajor, versionMinor);
 134                 rdpdr->versionMajor = versionMajor;
 135                 rdpdr->versionMinor = versionMinor;
 136         }
 137
 138         if (clientID != rdpdr->clientID)
 139         {
 140                 DEBUG_WARN("unmatched clientID %d", clientID);
 141                 rdpdr->clientID = clientID;
 142         }
 143 }
 144
 145 static void rdpdr_send_device_list_announce_request(rdpdrPlugin* rdpdr, boolean user_loggedon)
 146 {
 147         int i;
 148         int pos;
 149         uint8 c;
 150         uint32 count;
 151         int data_len;
 152         int count_pos;
 153         STREAM* data_out;
 154         DEVICE* device;
 155         LIST_ITEM* item;
 156
 157         data_out = stream_new(256);
 158
 159         stream_write_uint16(data_out, RDPDR_CTYP_CORE);
 160         stream_write_uint16(data_out, PAKID_CORE_DEVICELIST_ANNOUNCE);
 161
 162         count_pos = stream_get_pos(data_out);
 163         count = 0;
 164         stream_seek_uint32(data_out); /* deviceCount */
 165
 166         for (item = rdpdr->devman->devices->head; item; item = item->next)
 167         {
 168                 device = (DEVICE*) item->data;
 169
 170                 /**
 171                  * 1. versionMinor 0x0005 doesn't send PAKID_CORE_USER_LOGGEDON
 172                  *    so all devices should be sent regardless of user_loggedon
 173                  * 2. smartcard devices should be always sent
 174                  * 3. other devices are sent only after user_loggedon
 175                  */
 176                 if (rdpdr->versionMinor == 0x0005 ||
 177                         device->type == RDPDR_DTYP_SMARTCARD ||
 178                         user_loggedon)
 179                 {
 180                         data_len = (device->data == NULL ? 0 : stream_get_length(device->data));
 181                         stream_check_size(data_out, 20 + data_len);
 182
 183                         stream_write_uint32(data_out, device->type); /* deviceType */
 184                         stream_write_uint32(data_out, device->id); /* deviceID */
 185                         strncpy((char*) stream_get_tail(data_out), device->name, 8);
 186
 187                         for (i = 0; i < 8; i++)
 188                         {
 189                                 stream_peek_uint8(data_out, c);
 190
 191                                 if (c > 0x7F)
 192                                         stream_write_uint8(data_out, '_');
 193                                 else
 194                                         stream_seek_uint8(data_out);
 195                         }
 196
 197                         stream_write_uint32(data_out, data_len);
 198
 199                         if (data_len > 0)
 200                                 stream_write(data_out, stream_get_data(device->data), data_len);
 201
 202                         count++;
 203
 204                         printf("registered device #%d: %s (type=%d id=%d)\n",
 205                                 count, device->name, device->type, device->id);
 206                 }
 207         }
 208
 209         pos = stream_get_pos(data_out);
 210         stream_set_pos(data_out, count_pos);
 211         stream_write_uint32(data_out, count);
 212         stream_set_pos(data_out, pos);
 213         stream_seal(data_out);
 214
 215         svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
 216 }
 217
 218 static boolean rdpdr_process_irp(rdpdrPlugin* rdpdr, STREAM* data_in)
 219 {
 220         IRP* irp;
 221
 222         irp = irp_new(rdpdr->devman, data_in);
 223
 224         if (irp == NULL)
 225                 return false;
 226
 227         IFCALL(irp->device->IRPRequest, irp->device, irp);
 228
 229         return true;
 230 }
 231
 232 static void rdpdr_process_receive(rdpSvcPlugin* plugin, STREAM* data_in)
 233 {
 234         rdpdrPlugin* rdpdr = (rdpdrPlugin*) plugin;
 235         uint16 component;
 236         uint16 packetID;
 237         uint32 deviceID;
 238         uint32 status;
 239
 240         stream_read_uint16(data_in, component);
 241         stream_read_uint16(data_in, packetID);
 242
 243         if (component == RDPDR_CTYP_CORE)
 244         {
 245                 switch (packetID)
 246                 {
 247                         case PAKID_CORE_SERVER_ANNOUNCE:
 248                                 DEBUG_SVC("RDPDR_CTYP_CORE / PAKID_CORE_SERVER_ANNOUNCE");
 249                                 rdpdr_process_server_announce_request(rdpdr, data_in);
 250                                 rdpdr_send_client_announce_reply(rdpdr);
 251                                 rdpdr_send_client_name_request(rdpdr);
 252                                 break;
 253
 254                         case PAKID_CORE_SERVER_CAPABILITY:
 255                                 DEBUG_SVC("RDPDR_CTYP_CORE / PAKID_CORE_SERVER_CAPABILITY");
 256                                 rdpdr_process_capability_request(rdpdr, data_in);
 257                                 rdpdr_send_capability_response(rdpdr);
 258                                 break;
 259
 260                         case PAKID_CORE_CLIENTID_CONFIRM:
 261                                 DEBUG_SVC("RDPDR_CTYP_CORE / PAKID_CORE_CLIENTID_CONFIRM");
 262                                 rdpdr_process_server_clientid_confirm(rdpdr, data_in);
 263                                 rdpdr_send_device_list_announce_request(rdpdr, false);
 264                                 break;
 265
 266                         case PAKID_CORE_USER_LOGGEDON:
 267                                 DEBUG_SVC("RDPDR_CTYP_CORE / PAKID_CORE_USER_LOGGEDON");
 268                                 rdpdr_send_device_list_announce_request(rdpdr, true);
 269                                 break;
 270
 271                         case PAKID_CORE_DEVICE_REPLY:
 272                                 /* connect to a specific resource */
 273                                 stream_read_uint32(data_in, deviceID);
 274                                 stream_read_uint32(data_in, status);
 275                                 DEBUG_SVC("RDPDR_CTYP_CORE / PAKID_CORE_DEVICE_REPLY (deviceID=%d status=0x%08X)", deviceID, status);
 276                                 break;
 277
 278                         case PAKID_CORE_DEVICE_IOREQUEST:
 279                                 DEBUG_SVC("RDPDR_CTYP_CORE / PAKID_CORE_DEVICE_IOREQUEST");
 280                                 if (rdpdr_process_irp(rdpdr, data_in))
 281                                         data_in = NULL;
 282                                 break;
 283
 284                         default:
 285                                 DEBUG_WARN("RDPDR_CTYP_CORE / unknown packetID: 0x%02X", packetID);
 286                                 break;
 287
 288                 }
 289         }
 290         else if (component == RDPDR_CTYP_PRN)
 291         {
 292                 DEBUG_SVC("RDPDR_CTYP_PRN");
 293         }
 294         else
 295         {
 296                 DEBUG_WARN("RDPDR component: 0x%02X packetID: 0x%02X\n", component, packetID);
 297         }
 298
 299         stream_free(data_in);
 300 }
 301
 302 static void rdpdr_process_event(rdpSvcPlugin* plugin, RDP_EVENT* event)
 303 {
 304         freerdp_event_free(event);
 305 }
 306
 307 static void rdpdr_process_terminate(rdpSvcPlugin* plugin)
 308 {
 309         rdpdrPlugin* rdpdr = (rdpdrPlugin*) plugin;
 310
 311         devman_free(rdpdr->devman);
 312         xfree(plugin);
 313 }
 314
 315 DEFINE_SVC_PLUGIN(rdpdr, "rdpdr",
 316         CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP |
 317         CHANNEL_OPTION_COMPRESS_RDP)