2 * FreeRDP: A Remote Desktop Protocol client.
3 * File System Virtual Channel
5 * Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
6 * Copyright 2010-2011 Vic Lee
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 #include <freerdp/utils/memory.h>
27 #include <freerdp/utils/stream.h>
28 #include <freerdp/utils/unicode.h>
29 #include <freerdp/utils/list.h>
30 #include <freerdp/utils/thread.h>
31 #include <freerdp/utils/svc_plugin.h>
33 #include "rdpdr_constants.h"
34 #include "rdpdr_types.h"
35 #include "disk_file.h"
37 typedef struct _DISK_DEVICE DISK_DEVICE;
46 freerdp_thread* thread;
51 disk_map_posix_err(int fs_errno)
55 /* try to return NTSTATUS version of error code */
60 rc = STATUS_ACCESS_DENIED;
63 rc = STATUS_NO_SUCH_FILE;
66 rc = STATUS_DEVICE_BUSY;
69 rc = STATUS_OBJECT_NAME_COLLISION;
72 rc = STATUS_FILE_IS_A_DIRECTORY;
76 rc = STATUS_UNSUCCESSFUL;
79 DEBUG_SVC("errno 0x%x mapped to 0x%x\n", fs_errno, rc);
83 static DISK_FILE* disk_get_file_by_id(DISK_DEVICE* disk, uint32 id)
88 for (item = disk->files->head; item; item = item->next)
90 file = (DISK_FILE*)item->data;
97 static void disk_process_irp_create(DISK_DEVICE* disk, IRP* irp)
100 uint32 DesiredAccess;
101 uint32 CreateDisposition;
102 uint32 CreateOptions;
109 stream_read_uint32(irp->input, DesiredAccess);
110 stream_seek(irp->input, 16); /* AllocationSize(8), FileAttributes(4), SharedAccess(4) */
111 stream_read_uint32(irp->input, CreateDisposition);
112 stream_read_uint32(irp->input, CreateOptions);
113 stream_read_uint32(irp->input, PathLength);
115 uniconv = freerdp_uniconv_new();
116 path = freerdp_uniconv_in(uniconv, stream_get_tail(irp->input), PathLength);
117 freerdp_uniconv_free(uniconv);
119 FileId = irp->devman->id_sequence++;
120 file = disk_file_new(disk->path, path, FileId,
121 DesiredAccess, CreateDisposition, CreateOptions);
125 irp->IoStatus = STATUS_UNSUCCESSFUL;
129 DEBUG_WARN("failed to create %s.", path);
136 /* map errno to windows result*/
137 irp->IoStatus = disk_map_posix_err(file->err);
139 disk_file_free(file);
143 list_enqueue(disk->files, file);
145 switch (CreateDisposition)
151 Information = FILE_SUPERSEDED;
154 Information = FILE_OPENED;
156 case FILE_OVERWRITE_IF:
157 Information = FILE_OVERWRITTEN;
163 DEBUG_SVC("%s(%d) created.", file->fullpath, file->id);
166 stream_write_uint32(irp->output, FileId);
167 stream_write_uint8(irp->output, Information);
174 static void disk_process_irp_close(DISK_DEVICE* disk, IRP* irp)
178 file = disk_get_file_by_id(disk, irp->FileId);
182 irp->IoStatus = STATUS_UNSUCCESSFUL;
184 DEBUG_WARN("FileId %d not valid.", irp->FileId);
188 DEBUG_SVC("%s(%d) closed.", file->fullpath, file->id);
190 list_remove(disk->files, file);
191 disk_file_free(file);
194 stream_write_zero(irp->output, 5); /* Padding(5) */
199 static void disk_process_irp_read(DISK_DEVICE* disk, IRP* irp)
204 uint8* buffer = NULL;
206 stream_read_uint32(irp->input, Length);
207 stream_read_uint64(irp->input, Offset);
209 file = disk_get_file_by_id(disk, irp->FileId);
213 irp->IoStatus = STATUS_UNSUCCESSFUL;
216 DEBUG_WARN("FileId %d not valid.", irp->FileId);
218 else if (!disk_file_seek(file, Offset))
220 irp->IoStatus = STATUS_UNSUCCESSFUL;
223 DEBUG_WARN("seek %s(%d) failed.", file->fullpath, file->id);
227 buffer = (uint8*)xmalloc(Length);
228 if (!disk_file_read(file, buffer, &Length))
230 irp->IoStatus = STATUS_UNSUCCESSFUL;
235 DEBUG_WARN("read %s(%d) failed.", file->fullpath, file->id);
239 DEBUG_SVC("read %llu-%llu from %s(%d).", Offset, Offset + Length, file->fullpath, file->id);
243 stream_write_uint32(irp->output, Length);
246 stream_check_size(irp->output, Length);
247 stream_write(irp->output, buffer, Length);
254 static void disk_process_irp_write(DISK_DEVICE* disk, IRP* irp)
260 stream_read_uint32(irp->input, Length);
261 stream_read_uint64(irp->input, Offset);
262 stream_seek(irp->input, 20); /* Padding */
264 file = disk_get_file_by_id(disk, irp->FileId);
268 irp->IoStatus = STATUS_UNSUCCESSFUL;
271 DEBUG_WARN("FileId %d not valid.", irp->FileId);
273 else if (!disk_file_seek(file, Offset))
275 irp->IoStatus = STATUS_UNSUCCESSFUL;
278 DEBUG_WARN("seek %s(%d) failed.", file->fullpath, file->id);
280 else if (!disk_file_write(file, stream_get_tail(irp->input), Length))
282 irp->IoStatus = STATUS_UNSUCCESSFUL;
285 DEBUG_WARN("write %s(%d) failed.", file->fullpath, file->id);
289 DEBUG_SVC("write %llu-%llu to %s(%d).", Offset, Offset + Length, file->fullpath, file->id);
292 stream_write_uint32(irp->output, Length);
293 stream_write_uint8(irp->output, 0); /* Padding */
298 static void disk_process_irp_query_information(DISK_DEVICE* disk, IRP* irp)
301 uint32 FsInformationClass;
303 stream_read_uint32(irp->input, FsInformationClass);
305 file = disk_get_file_by_id(disk, irp->FileId);
309 irp->IoStatus = STATUS_UNSUCCESSFUL;
311 DEBUG_WARN("FileId %d not valid.", irp->FileId);
313 else if (!disk_file_query_information(file, FsInformationClass, irp->output))
315 irp->IoStatus = STATUS_UNSUCCESSFUL;
317 DEBUG_WARN("FsInformationClass %d on %s(%d) failed.", FsInformationClass, file->fullpath, file->id);
321 DEBUG_SVC("FsInformationClass %d on %s(%d).", FsInformationClass, file->fullpath, file->id);
327 static void disk_process_irp_set_information(DISK_DEVICE* disk, IRP* irp)
330 uint32 FsInformationClass;
333 stream_read_uint32(irp->input, FsInformationClass);
334 stream_read_uint32(irp->input, Length);
335 stream_seek(irp->input, 24); /* Padding */
337 file = disk_get_file_by_id(disk, irp->FileId);
341 irp->IoStatus = STATUS_UNSUCCESSFUL;
343 DEBUG_WARN("FileId %d not valid.", irp->FileId);
345 else if (!disk_file_set_information(file, FsInformationClass, Length, irp->input))
347 irp->IoStatus = STATUS_UNSUCCESSFUL;
349 DEBUG_WARN("FsInformationClass %d on %s(%d) failed.", FsInformationClass, file->fullpath, file->id);
353 DEBUG_SVC("FsInformationClass %d on %s(%d) ok.", FsInformationClass, file->fullpath, file->id);
356 stream_write_uint32(irp->output, Length);
361 static void disk_process_irp_query_volume_information(DISK_DEVICE* disk, IRP* irp)
363 uint32 FsInformationClass;
364 STREAM* output = irp->output;
366 stream_read_uint32(irp->input, FsInformationClass);
368 switch (FsInformationClass)
370 case FileFsVolumeInformation:
371 /* http://msdn.microsoft.com/en-us/library/cc232108.aspx */
372 stream_write_uint32(output, 34); /* Length */
373 stream_check_size(output, 34);
374 stream_write_uint64(output, 0); /* VolumeCreationTime */
375 stream_write_uint32(output, 0); /* VolumeSerialNumber */
376 stream_write_uint32(output, 16); /* VolumeLabelLength */
377 stream_write_uint8(output, 0); /* SupportsObjects */
378 stream_write_uint8(output, 0); /* Reserved */
379 stream_write(output, "F\0R\0E\0E\0R\0D\0P\0\0\0", 16); /* VolumeLabel (Unicode) */
382 case FileFsSizeInformation:
383 /* http://msdn.microsoft.com/en-us/library/cc232107.aspx */
384 stream_write_uint32(output, 24); /* Length */
385 stream_check_size(output, 24);
386 stream_write_uint64(output, 0x1000000); /* TotalAllocationUnits */
387 stream_write_uint64(output, 0x800000); /* AvailableAllocationUnits */
388 stream_write_uint32(output, 1); /* SectorsPerAllocationUnit */
389 stream_write_uint32(output, 0x400); /* BytesPerSector */
392 case FileFsAttributeInformation:
393 /* http://msdn.microsoft.com/en-us/library/cc232101.aspx */
394 stream_write_uint32(output, 22); /* Length */
395 stream_check_size(output, 22);
396 stream_write_uint32(output,
397 FILE_CASE_SENSITIVE_SEARCH |
398 FILE_CASE_PRESERVED_NAMES |
399 FILE_UNICODE_ON_DISK); /* FileSystemAttributes */
400 stream_write_uint32(output, 510); /* MaximumComponentNameLength */
401 stream_write_uint32(output, 10); /* FileSystemNameLength */
402 stream_write(output, "F\0A\0T\03\02\0", 10); /* FileSystemName */
405 case FileFsFullSizeInformation:
406 /* http://msdn.microsoft.com/en-us/library/cc232104.aspx */
407 stream_write_uint32(output, 32); /* Length */
408 stream_check_size(output, 32);
409 stream_write_uint64(output, 0x1000000); /* TotalAllocationUnits */
410 stream_write_uint64(output, 0x800000); /* CallerAvailableAllocationUnits */
411 stream_write_uint64(output, 0x800000); /* ActualAvailableAllocationUnits */
412 stream_write_uint32(output, 1); /* SectorsPerAllocationUnit */
413 stream_write_uint32(output, 0x400); /* BytesPerSector */
416 case FileFsDeviceInformation:
417 /* http://msdn.microsoft.com/en-us/library/cc232109.aspx */
418 stream_write_uint32(output, 8); /* Length */
419 stream_check_size(output, 8);
420 stream_write_uint32(output, FILE_DEVICE_DISK); /* DeviceType */
421 stream_write_uint32(output, 0); /* Characteristics */
425 irp->IoStatus = STATUS_UNSUCCESSFUL;
426 stream_write_uint32(output, 0); /* Length */
427 DEBUG_WARN("invalid FsInformationClass %d", FsInformationClass);
434 static void disk_process_irp_query_directory(DISK_DEVICE* disk, IRP* irp)
437 uint32 FsInformationClass;
443 stream_read_uint32(irp->input, FsInformationClass);
444 stream_read_uint8(irp->input, InitialQuery);
445 stream_read_uint32(irp->input, PathLength);
446 stream_seek(irp->input, 23); /* Padding */
448 uniconv = freerdp_uniconv_new();
449 path = freerdp_uniconv_in(uniconv, stream_get_tail(irp->input), PathLength);
450 freerdp_uniconv_free(uniconv);
452 file = disk_get_file_by_id(disk, irp->FileId);
456 irp->IoStatus = STATUS_UNSUCCESSFUL;
457 stream_write_uint32(irp->output, 0); /* Length */
458 DEBUG_WARN("FileId %d not valid.", irp->FileId);
460 else if (!disk_file_query_directory(file, FsInformationClass, InitialQuery, path, irp->output))
462 irp->IoStatus = STATUS_NO_MORE_FILES;
470 static void disk_process_irp_directory_control(DISK_DEVICE* disk, IRP* irp)
472 switch (irp->MinorFunction)
474 case IRP_MN_QUERY_DIRECTORY:
475 disk_process_irp_query_directory(disk, irp);
478 case IRP_MN_NOTIFY_CHANGE_DIRECTORY: /* TODO */
483 DEBUG_WARN("MinorFunction 0x%X not supported", irp->MinorFunction);
484 irp->IoStatus = STATUS_NOT_SUPPORTED;
485 stream_write_uint32(irp->output, 0); /* Length */
491 static void disk_process_irp_device_control(DISK_DEVICE* disk, IRP* irp)
493 stream_write_uint32(irp->output, 0); /* OutputBufferLength */
497 static void disk_process_irp(DISK_DEVICE* disk, IRP* irp)
499 switch (irp->MajorFunction)
502 disk_process_irp_create(disk, irp);
506 disk_process_irp_close(disk, irp);
510 disk_process_irp_read(disk, irp);
514 disk_process_irp_write(disk, irp);
517 case IRP_MJ_QUERY_INFORMATION:
518 disk_process_irp_query_information(disk, irp);
521 case IRP_MJ_SET_INFORMATION:
522 disk_process_irp_set_information(disk, irp);
525 case IRP_MJ_QUERY_VOLUME_INFORMATION:
526 disk_process_irp_query_volume_information(disk, irp);
529 case IRP_MJ_DIRECTORY_CONTROL:
530 disk_process_irp_directory_control(disk, irp);
533 case IRP_MJ_DEVICE_CONTROL:
534 disk_process_irp_device_control(disk, irp);
538 DEBUG_WARN("MajorFunction 0x%X not supported", irp->MajorFunction);
539 irp->IoStatus = STATUS_NOT_SUPPORTED;
545 static void disk_process_irp_list(DISK_DEVICE* disk)
551 if (freerdp_thread_is_stopped(disk->thread))
554 freerdp_thread_lock(disk->thread);
555 irp = (IRP*)list_dequeue(disk->irp_list);
556 freerdp_thread_unlock(disk->thread);
561 disk_process_irp(disk, irp);
565 static void* disk_thread_func(void* arg)
567 DISK_DEVICE* disk = (DISK_DEVICE*)arg;
571 freerdp_thread_wait(disk->thread);
573 if (freerdp_thread_is_stopped(disk->thread))
576 freerdp_thread_reset(disk->thread);
577 disk_process_irp_list(disk);
580 freerdp_thread_quit(disk->thread);
585 static void disk_irp_request(DEVICE* device, IRP* irp)
587 DISK_DEVICE* disk = (DISK_DEVICE*)device;
589 freerdp_thread_lock(disk->thread);
590 list_enqueue(disk->irp_list, irp);
591 freerdp_thread_unlock(disk->thread);
593 freerdp_thread_signal(disk->thread);
596 static void disk_free(DEVICE* device)
598 DISK_DEVICE* disk = (DISK_DEVICE*)device;
602 freerdp_thread_stop(disk->thread);
603 freerdp_thread_free(disk->thread);
605 while ((irp = (IRP*)list_dequeue(disk->irp_list)) != NULL)
607 list_free(disk->irp_list);
609 while ((file = (DISK_FILE*)list_dequeue(disk->files)) != NULL)
610 disk_file_free(file);
611 list_free(disk->files);
615 int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)
622 name = (char*)pEntryPoints->plugin_data->data[1];
623 path = (char*)pEntryPoints->plugin_data->data[2];
625 if (name[0] && path[0])
627 disk = xnew(DISK_DEVICE);
629 disk->device.type = RDPDR_DTYP_FILESYSTEM;
630 disk->device.name = name;
631 disk->device.IRPRequest = disk_irp_request;
632 disk->device.Free = disk_free;
635 disk->device.data = stream_new(len + 1);
636 for (i = 0; i <= len; i++)
637 stream_write_uint8(disk->device.data, name[i] < 0 ? '_' : name[i]);
640 disk->files = list_new();
642 disk->irp_list = list_new();
643 disk->thread = freerdp_thread_new();
645 pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE*)disk);
647 freerdp_thread_start(disk->thread, disk_thread_func, disk);