wininet: Store hostname for secure connection in its SSL context.
[wine] / dlls / mountmgr.sys / mountmgr.c
1 /*
2  * Mount manager service implementation
3  *
4  * Copyright 2008 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22 #include <unistd.h>
23
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
26
27 #include "mountmgr.h"
28 #include "winreg.h"
29 #include "wine/library.h"
30 #include "wine/list.h"
31 #include "wine/unicode.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(mountmgr);
35
36 #define MIN_ID_LEN     4
37
38 struct mount_point
39 {
40     struct list    entry;   /* entry in mount points list */
41     DEVICE_OBJECT *device;  /* disk device */
42     UNICODE_STRING name;    /* device name */
43     UNICODE_STRING link;    /* DOS device symlink */
44     void          *id;      /* device unique id */
45     unsigned int   id_len;
46 };
47
48 static struct list mount_points_list = LIST_INIT(mount_points_list);
49 static HKEY mount_key;
50
51 void set_mount_point_id( struct mount_point *mount, const void *id, unsigned int id_len )
52 {
53     RtlFreeHeap( GetProcessHeap(), 0, mount->id );
54     mount->id_len = max( MIN_ID_LEN, id_len );
55     if ((mount->id = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, mount->id_len )))
56     {
57         memcpy( mount->id, id, id_len );
58         RegSetValueExW( mount_key, mount->link.Buffer, 0, REG_BINARY, mount->id, mount->id_len );
59     }
60     else mount->id_len = 0;
61 }
62
63 static struct mount_point *add_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name,
64                                             const WCHAR *link )
65 {
66     struct mount_point *mount;
67     WCHAR *str;
68     UINT len = (strlenW(link) + 1) * sizeof(WCHAR) + device_name->Length + sizeof(WCHAR);
69
70     if (!(mount = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*mount) + len ))) return NULL;
71
72     str = (WCHAR *)(mount + 1);
73     strcpyW( str, link );
74     RtlInitUnicodeString( &mount->link, str );
75     str += strlenW(str) + 1;
76     memcpy( str, device_name->Buffer, device_name->Length );
77     str[device_name->Length / sizeof(WCHAR)] = 0;
78     mount->name.Buffer = str;
79     mount->name.Length = device_name->Length;
80     mount->name.MaximumLength = device_name->Length + sizeof(WCHAR);
81     mount->device = device;
82     mount->id = NULL;
83     list_add_tail( &mount_points_list, &mount->entry );
84
85     IoCreateSymbolicLink( &mount->link, device_name );
86
87     TRACE( "created %s id %s for %s\n", debugstr_w(mount->link.Buffer),
88            debugstr_a(mount->id), debugstr_w(mount->name.Buffer) );
89     return mount;
90 }
91
92 /* create the DosDevices mount point symlink for a new device */
93 struct mount_point *add_dosdev_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name, int drive )
94 {
95     static const WCHAR driveW[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','%','c',':',0};
96     WCHAR link[sizeof(driveW)];
97
98     sprintfW( link, driveW, 'A' + drive );
99     return add_mount_point( device, device_name, link );
100 }
101
102 /* create the Volume mount point symlink for a new device */
103 struct mount_point *add_volume_mount_point( DEVICE_OBJECT *device, UNICODE_STRING *device_name,
104                                             const GUID *guid )
105 {
106     static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{',
107                                     '%','0','8','x','-','%','0','4','x','-','%','0','4','x','-',
108                                     '%','0','2','x','%','0','2','x','-','%','0','2','x','%','0','2','x',
109                                     '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0};
110     WCHAR link[sizeof(volumeW)];
111
112     sprintfW( link, volumeW, guid->Data1, guid->Data2, guid->Data3,
113               guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
114               guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
115     return add_mount_point( device, device_name, link );
116 }
117
118 /* delete the mount point symlinks when a device goes away */
119 void delete_mount_point( struct mount_point *mount )
120 {
121     TRACE( "deleting %s\n", debugstr_w(mount->link.Buffer) );
122     list_remove( &mount->entry );
123     RegDeleteValueW( mount_key, mount->link.Buffer );
124     IoDeleteSymbolicLink( &mount->link );
125     RtlFreeHeap( GetProcessHeap(), 0, mount->id );
126     RtlFreeHeap( GetProcessHeap(), 0, mount );
127 }
128
129 /* check if a given mount point matches the requested specs */
130 static BOOL matching_mount_point( const struct mount_point *mount, const MOUNTMGR_MOUNT_POINT *spec )
131 {
132     if (spec->SymbolicLinkNameOffset)
133     {
134         const WCHAR *name = (const WCHAR *)((const char *)spec + spec->SymbolicLinkNameOffset);
135         if (spec->SymbolicLinkNameLength != mount->link.Length) return FALSE;
136         if (memicmpW( name, mount->link.Buffer, mount->link.Length/sizeof(WCHAR)))
137             return FALSE;
138     }
139     if (spec->DeviceNameOffset)
140     {
141         const WCHAR *name = (const WCHAR *)((const char *)spec + spec->DeviceNameOffset);
142         if (spec->DeviceNameLength != mount->name.Length) return FALSE;
143         if (memicmpW( name, mount->name.Buffer, mount->name.Length/sizeof(WCHAR)))
144             return FALSE;
145     }
146     if (spec->UniqueIdOffset)
147     {
148         const void *id = ((const char *)spec + spec->UniqueIdOffset);
149         if (spec->UniqueIdLength != mount->id_len) return FALSE;
150         if (memcmp( id, mount->id, mount->id_len )) return FALSE;
151     }
152     return TRUE;
153 }
154
155 /* implementation of IOCTL_MOUNTMGR_QUERY_POINTS */
156 static NTSTATUS query_mount_points( const void *in_buff, SIZE_T insize,
157                                     void *out_buff, SIZE_T outsize, IO_STATUS_BLOCK *iosb )
158 {
159     UINT count, pos, size;
160     const MOUNTMGR_MOUNT_POINT *input = in_buff;
161     MOUNTMGR_MOUNT_POINTS *info = out_buff;
162     struct mount_point *mount;
163
164     /* sanity checks */
165     if (input->SymbolicLinkNameOffset + input->SymbolicLinkNameLength > insize ||
166         input->UniqueIdOffset + input->UniqueIdLength > insize ||
167         input->DeviceNameOffset + input->DeviceNameLength > insize ||
168         input->SymbolicLinkNameOffset + input->SymbolicLinkNameLength < input->SymbolicLinkNameOffset ||
169         input->UniqueIdOffset + input->UniqueIdLength < input->UniqueIdOffset ||
170         input->DeviceNameOffset + input->DeviceNameLength < input->DeviceNameOffset)
171         return STATUS_INVALID_PARAMETER;
172
173     count = size = 0;
174     LIST_FOR_EACH_ENTRY( mount, &mount_points_list, struct mount_point, entry )
175     {
176         if (!matching_mount_point( mount, input )) continue;
177         size += mount->name.Length;
178         size += mount->link.Length;
179         size += mount->id_len;
180         size = (size + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
181         count++;
182     }
183     pos = FIELD_OFFSET( MOUNTMGR_MOUNT_POINTS, MountPoints[count] );
184     size += pos;
185
186     if (size > outsize)
187     {
188         if (size >= sizeof(info->Size)) info->Size = size;
189         iosb->Information = sizeof(info->Size);
190         return STATUS_MORE_ENTRIES;
191     }
192
193     info->NumberOfMountPoints = count;
194     count = 0;
195     LIST_FOR_EACH_ENTRY( mount, &mount_points_list, struct mount_point, entry )
196     {
197         if (!matching_mount_point( mount, input )) continue;
198
199         info->MountPoints[count].DeviceNameOffset = pos;
200         info->MountPoints[count].DeviceNameLength = mount->name.Length;
201         memcpy( (char *)out_buff + pos, mount->name.Buffer, mount->name.Length );
202         pos += mount->name.Length;
203
204         info->MountPoints[count].SymbolicLinkNameOffset = pos;
205         info->MountPoints[count].SymbolicLinkNameLength = mount->link.Length;
206         memcpy( (char *)out_buff + pos, mount->link.Buffer, mount->link.Length );
207         pos += mount->link.Length;
208
209         info->MountPoints[count].UniqueIdOffset = pos;
210         info->MountPoints[count].UniqueIdLength = mount->id_len;
211         memcpy( (char *)out_buff + pos, mount->id, mount->id_len );
212         pos += mount->id_len;
213         pos = (pos + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
214         count++;
215     }
216     info->Size = pos;
217     iosb->Information = pos;
218     return STATUS_SUCCESS;
219 }
220
221 /* implementation of IOCTL_MOUNTMGR_DEFINE_UNIX_DRIVE */
222 static NTSTATUS define_unix_drive( const void *in_buff, SIZE_T insize )
223 {
224     const struct mountmgr_unix_drive *input = in_buff;
225     const char *mount_point = NULL, *device = NULL;
226     unsigned int i;
227     WCHAR letter = tolowerW( input->letter );
228
229     if (letter < 'a' || letter > 'z') return STATUS_INVALID_PARAMETER;
230     if (input->type > DRIVE_RAMDISK) return STATUS_INVALID_PARAMETER;
231     if (input->mount_point_offset > insize || input->device_offset > insize)
232         return STATUS_INVALID_PARAMETER;
233
234     /* make sure string are null-terminated */
235     if (input->mount_point_offset)
236     {
237         mount_point = (const char *)in_buff + input->mount_point_offset;
238         for (i = input->mount_point_offset; i < insize; i++)
239             if (!*((const char *)in_buff + i)) break;
240         if (i >= insize) return STATUS_INVALID_PARAMETER;
241     }
242     if (input->device_offset)
243     {
244         device = (const char *)in_buff + input->device_offset;
245         for (i = input->device_offset; i < insize; i++)
246             if (!*((const char *)in_buff + i)) break;
247         if (i >= insize) return STATUS_INVALID_PARAMETER;
248     }
249
250     if (input->type != DRIVE_NO_ROOT_DIR)
251     {
252         enum device_type type = DEVICE_UNKNOWN;
253
254         TRACE( "defining %c: dev %s mount %s type %u\n",
255                letter, debugstr_a(device), debugstr_a(mount_point), input->type );
256         switch (input->type)
257         {
258         case DRIVE_REMOVABLE: type = (letter >= 'c') ? DEVICE_HARDDISK : DEVICE_FLOPPY; break;
259         case DRIVE_REMOTE:    type = DEVICE_NETWORK; break;
260         case DRIVE_CDROM:     type = DEVICE_CDROM; break;
261         case DRIVE_RAMDISK:   type = DEVICE_RAMDISK; break;
262         case DRIVE_FIXED:     type = DEVICE_HARDDISK_VOL; break;
263         }
264         return add_dos_device( letter - 'a', NULL, device, mount_point, type, NULL );
265     }
266     else
267     {
268         TRACE( "removing %c:\n", letter );
269         return remove_dos_device( letter - 'a', NULL );
270     }
271 }
272
273 /* implementation of IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE */
274 static NTSTATUS query_unix_drive( const void *in_buff, SIZE_T insize,
275                                   void *out_buff, SIZE_T outsize, IO_STATUS_BLOCK *iosb )
276 {
277     const struct mountmgr_unix_drive *input = in_buff;
278     struct mountmgr_unix_drive *output = out_buff;
279     char *device, *mount_point;
280     int letter = tolowerW( input->letter );
281     NTSTATUS status;
282     DWORD size, type = DEVICE_UNKNOWN;
283     enum device_type device_type;
284     char *ptr;
285
286     if (letter < 'a' || letter > 'z') return STATUS_INVALID_PARAMETER;
287
288     if ((status = query_dos_device( letter - 'a', &device_type, &device, &mount_point ))) return status;
289     switch (device_type)
290     {
291     case DEVICE_UNKNOWN:      type = DRIVE_UNKNOWN; break;
292     case DEVICE_HARDDISK:     type = DRIVE_REMOVABLE; break;
293     case DEVICE_HARDDISK_VOL: type = DRIVE_FIXED; break;
294     case DEVICE_FLOPPY:       type = DRIVE_REMOVABLE; break;
295     case DEVICE_CDROM:        type = DRIVE_CDROM; break;
296     case DEVICE_NETWORK:      type = DRIVE_REMOTE; break;
297     case DEVICE_RAMDISK:      type = DRIVE_RAMDISK; break;
298     }
299
300     size = sizeof(*output);
301     if (device) size += strlen(device) + 1;
302     if (mount_point) size += strlen(mount_point) + 1;
303
304     if (size > outsize)
305     {
306         iosb->Information = 0;
307         if (size >= FIELD_OFFSET( struct mountmgr_unix_drive, size ) + sizeof(output->size))
308         {
309             output->size = size;
310             iosb->Information = FIELD_OFFSET( struct mountmgr_unix_drive, size ) + sizeof(output->size);
311         }
312         if (size >= FIELD_OFFSET( struct mountmgr_unix_drive, type ) + sizeof(output->type))
313         {
314             output->type = type;
315             iosb->Information = FIELD_OFFSET( struct mountmgr_unix_drive, type ) + sizeof(output->type);
316         }
317         status = STATUS_MORE_ENTRIES;
318         goto done;
319     }
320     output->size = size;
321     output->letter = letter;
322     output->type = type;
323     ptr = (char *)(output + 1);
324
325     if (mount_point)
326     {
327         output->mount_point_offset = ptr - (char *)output;
328         strcpy( ptr, mount_point );
329         ptr += strlen(ptr) + 1;
330     }
331     else output->mount_point_offset = 0;
332
333     if (device)
334     {
335         output->device_offset = ptr - (char *)output;
336         strcpy( ptr, device );
337         ptr += strlen(ptr) + 1;
338     }
339     else output->device_offset = 0;
340
341     TRACE( "returning %c: dev %s mount %s type %u\n",
342            letter, debugstr_a(device), debugstr_a(mount_point), type );
343
344     iosb->Information = ptr - (char *)output;
345 done:
346     RtlFreeHeap( GetProcessHeap(), 0, device );
347     RtlFreeHeap( GetProcessHeap(), 0, mount_point );
348     return status;
349 }
350
351 /* handler for ioctls on the mount manager device */
352 static NTSTATUS WINAPI mountmgr_ioctl( DEVICE_OBJECT *device, IRP *irp )
353 {
354     IO_STACK_LOCATION *irpsp = irp->Tail.Overlay.s.u.CurrentStackLocation;
355
356     TRACE( "ioctl %x insize %u outsize %u\n",
357            irpsp->Parameters.DeviceIoControl.IoControlCode,
358            irpsp->Parameters.DeviceIoControl.InputBufferLength,
359            irpsp->Parameters.DeviceIoControl.OutputBufferLength );
360
361     switch(irpsp->Parameters.DeviceIoControl.IoControlCode)
362     {
363     case IOCTL_MOUNTMGR_QUERY_POINTS:
364         if (irpsp->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_MOUNT_POINT))
365             return STATUS_INVALID_PARAMETER;
366         irp->IoStatus.u.Status = query_mount_points( irpsp->Parameters.DeviceIoControl.Type3InputBuffer,
367                                                      irpsp->Parameters.DeviceIoControl.InputBufferLength,
368                                                      irp->MdlAddress->StartVa,
369                                                      irpsp->Parameters.DeviceIoControl.OutputBufferLength,
370                                                      &irp->IoStatus );
371         break;
372     case IOCTL_MOUNTMGR_DEFINE_UNIX_DRIVE:
373         if (irpsp->Parameters.DeviceIoControl.InputBufferLength < sizeof(struct mountmgr_unix_drive))
374             return STATUS_INVALID_PARAMETER;
375         irp->IoStatus.Information = 0;
376         irp->IoStatus.u.Status = define_unix_drive( irpsp->Parameters.DeviceIoControl.Type3InputBuffer,
377                                                     irpsp->Parameters.DeviceIoControl.InputBufferLength );
378         break;
379     case IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE:
380         if (irpsp->Parameters.DeviceIoControl.InputBufferLength < sizeof(struct mountmgr_unix_drive))
381             return STATUS_INVALID_PARAMETER;
382         irp->IoStatus.u.Status = query_unix_drive( irpsp->Parameters.DeviceIoControl.Type3InputBuffer,
383                                                    irpsp->Parameters.DeviceIoControl.InputBufferLength,
384                                                    irp->MdlAddress->StartVa,
385                                                    irpsp->Parameters.DeviceIoControl.OutputBufferLength,
386                                                    &irp->IoStatus );
387         break;
388     default:
389         FIXME( "ioctl %x not supported\n", irpsp->Parameters.DeviceIoControl.IoControlCode );
390         irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
391         break;
392     }
393     return irp->IoStatus.u.Status;
394 }
395
396 /* main entry point for the mount point manager driver */
397 NTSTATUS WINAPI DriverEntry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
398 {
399     static const WCHAR mounted_devicesW[] = {'S','y','s','t','e','m','\\','M','o','u','n','t','e','d','D','e','v','i','c','e','s',0};
400     static const WCHAR device_mountmgrW[] = {'\\','D','e','v','i','c','e','\\','M','o','u','n','t','P','o','i','n','t','M','a','n','a','g','e','r',0};
401     static const WCHAR link_mountmgrW[] = {'\\','?','?','\\','M','o','u','n','t','P','o','i','n','t','M','a','n','a','g','e','r',0};
402     static const WCHAR harddiskW[] = {'\\','D','r','i','v','e','r','\\','H','a','r','d','d','i','s','k',0};
403     static const WCHAR devicemapW[] = {'H','A','R','D','W','A','R','E','\\','D','E','V','I','C','E','M','A','P',0};
404     static const WCHAR parallelW[] = {'P','A','R','A','L','L','E','L',' ','P','O','R','T','S',0};
405     static const WCHAR serialW[] = {'S','E','R','I','A','L','C','O','M','M',0};
406
407     UNICODE_STRING nameW, linkW;
408     DEVICE_OBJECT *device;
409     NTSTATUS status;
410     HKEY hkey, devicemap_key;
411
412     TRACE( "%s\n", debugstr_w(path->Buffer) );
413
414     driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = mountmgr_ioctl;
415
416     RtlInitUnicodeString( &nameW, device_mountmgrW );
417     RtlInitUnicodeString( &linkW, link_mountmgrW );
418     if (!(status = IoCreateDevice( driver, 0, &nameW, 0, 0, FALSE, &device )))
419         status = IoCreateSymbolicLink( &linkW, &nameW );
420     if (status)
421     {
422         FIXME( "failed to create device error %x\n", status );
423         return status;
424     }
425
426     RegCreateKeyExW( HKEY_LOCAL_MACHINE, mounted_devicesW, 0, NULL,
427                      REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &mount_key, NULL );
428
429     if (!RegCreateKeyExW( HKEY_LOCAL_MACHINE, devicemapW, 0, NULL, REG_OPTION_VOLATILE,
430                           KEY_ALL_ACCESS, NULL, &devicemap_key, NULL ))
431     {
432         if (!RegCreateKeyExW( devicemap_key, parallelW, 0, NULL, REG_OPTION_VOLATILE,
433                               KEY_ALL_ACCESS, NULL, &hkey, NULL ))
434             RegCloseKey( hkey );
435         if (!RegCreateKeyExW( devicemap_key, serialW, 0, NULL, REG_OPTION_VOLATILE,
436                               KEY_ALL_ACCESS, NULL, &hkey, NULL ))
437             RegCloseKey( hkey );
438         RegCloseKey( devicemap_key );
439     }
440
441     RtlInitUnicodeString( &nameW, harddiskW );
442     status = IoCreateDriver( &nameW, harddisk_driver_entry );
443
444     initialize_hal();
445     initialize_diskarbitration();
446
447     return status;
448 }