winecfg: Update Norwegian Bokmål translation.
[wine] / programs / winecfg / drive.c
1 /*
2  * Drive management code
3  *
4  * Copyright 2003 Mark Westcott
5  * Copyright 2003-2004 Mike Hearn
6  * Copyright 2004 Chris Morgan
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  *
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <assert.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #include <ntstatus.h>
33 #define WIN32_NO_STATUS
34 #include <windef.h>
35 #include <winbase.h>
36 #include <winternl.h>
37 #include <winioctl.h>
38 #include <winreg.h>
39 #include <wine/debug.h>
40 #include <shellapi.h>
41 #include <objbase.h>
42 #include <shlguid.h>
43 #include <shlwapi.h>
44 #include <shlobj.h>
45 #define WINE_MOUNTMGR_EXTENSIONS
46 #include <ddk/mountmgr.h>
47 #include <wine/library.h>
48
49 #include "winecfg.h"
50 #include "resource.h"
51
52
53 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
54
55 struct drive drives[26]; /* one for each drive letter */
56
57 static inline int letter_to_index(char letter)
58 {
59     return (toupper(letter) - 'A');
60 }
61
62 /* This function produces a mask for each drive letter that isn't
63  * currently used. Each bit of the long result represents a letter,
64  * with A being the least significant bit, and Z being the most
65  * significant.
66  *
67  * To calculate this, we loop over each letter, and see if we can get
68  * a drive entry for it. If so, we set the appropriate bit. At the
69  * end, we flip each bit, to give the desired result.
70  *
71  * The letter parameter is always marked as being available. This is
72  * so the edit dialog can display the currently used drive letter
73  * alongside the available ones.
74  */
75 ULONG drive_available_mask(char letter)
76 {
77   ULONG result = 0;
78   int i;
79
80   WINE_TRACE("\n");
81
82
83   for(i = 0; i < 26; i++)
84   {
85       if (!drives[i].in_use) continue;
86       result |= (1 << (letter_to_index(drives[i].letter)));
87   }
88
89   result = ~result;
90   if (letter) result |= DRIVE_MASK_BIT(letter);
91
92   WINE_TRACE("finished drive letter loop with %x\n", result);
93   return result;
94 }
95
96 BOOL add_drive(char letter, const char *targetpath, const char *device, const WCHAR *label,
97                DWORD serial, DWORD type)
98 {
99     int driveIndex = letter_to_index(letter);
100
101     if(drives[driveIndex].in_use)
102         return FALSE;
103
104     WINE_TRACE("letter == '%c', unixpath == %s, device == %s, label == %s, serial == %08x, type == %d\n",
105                letter, wine_dbgstr_a(targetpath), wine_dbgstr_a(device),
106                wine_dbgstr_w(label), serial, type);
107
108     drives[driveIndex].letter   = toupper(letter);
109     drives[driveIndex].unixpath = strdupA(targetpath);
110     drives[driveIndex].device   = device ? strdupA(device) : NULL;
111     drives[driveIndex].label    = label ? strdupW(label) : NULL;
112     drives[driveIndex].serial   = serial;
113     drives[driveIndex].type     = type;
114     drives[driveIndex].in_use   = TRUE;
115     drives[driveIndex].modified = TRUE;
116
117     return TRUE;
118 }
119
120 /* deallocates the contents of the drive. does not free the drive itself  */
121 void delete_drive(struct drive *d)
122 {
123     HeapFree(GetProcessHeap(), 0, d->unixpath);
124     d->unixpath = NULL;
125     HeapFree(GetProcessHeap(), 0, d->device);
126     d->device = NULL;
127     HeapFree(GetProcessHeap(), 0, d->label);
128     d->label = NULL;
129     d->serial = 0;
130     d->in_use = FALSE;
131     d->modified = TRUE;
132 }
133
134 static DWORD get_drive_type( char letter )
135 {
136     HKEY hKey;
137     char driveValue[4];
138     DWORD ret = DRIVE_UNKNOWN;
139
140     sprintf(driveValue, "%c:", letter);
141
142     if (RegOpenKey(HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hKey) != ERROR_SUCCESS)
143         WINE_TRACE("  Unable to open Software\\Wine\\Drives\n" );
144     else
145     {
146         char buffer[80];
147         DWORD size = sizeof(buffer);
148
149         if (!RegQueryValueExA( hKey, driveValue, NULL, NULL, (LPBYTE)buffer, &size ))
150         {
151             WINE_TRACE("Got type '%s' for %s\n", buffer, driveValue );
152             if (!lstrcmpi( buffer, "hd" )) ret = DRIVE_FIXED;
153             else if (!lstrcmpi( buffer, "network" )) ret = DRIVE_REMOTE;
154             else if (!lstrcmpi( buffer, "floppy" )) ret = DRIVE_REMOVABLE;
155             else if (!lstrcmpi( buffer, "cdrom" )) ret = DRIVE_CDROM;
156         }
157         RegCloseKey(hKey);
158     }
159     return ret;
160 }
161
162
163 static void set_drive_label( char letter, const WCHAR *label )
164 {
165     static const WCHAR emptyW[1];
166     WCHAR device[] = {'a',':','\\',0};  /* SetVolumeLabel() requires a trailing slash */
167     device[0] = letter;
168
169     if (!label) label = emptyW;
170     if(!SetVolumeLabelW(device, label))
171     {
172         WINE_WARN("unable to set volume label for devicename of %s, label of %s\n",
173                   wine_dbgstr_w(device), wine_dbgstr_w(label));
174         PRINTERROR();
175     }
176     else
177     {
178         WINE_TRACE("  set volume label for devicename of %s, label of %s\n",
179                   wine_dbgstr_w(device), wine_dbgstr_w(label));
180     }
181 }
182
183 /* set the drive serial number via a .windows-serial file */
184 static void set_drive_serial( char letter, DWORD serial )
185 {
186     char filename[] = "a:\\.windows-serial";
187     HANDLE hFile;
188
189     filename[0] = letter;
190     WINE_TRACE("Putting serial number of %08X into file '%s'\n", serial, filename);
191     hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
192                        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
193     if (hFile != INVALID_HANDLE_VALUE)
194     {
195         DWORD w;
196         char buffer[16];
197
198         sprintf( buffer, "%X\n", serial );
199         WriteFile(hFile, buffer, strlen(buffer), &w, NULL);
200         CloseHandle(hFile);
201     }
202 }
203
204 #if 0
205
206 /* currently unused, but if users have this burning desire to be able to rename drives,
207    we can put it back in.
208  */
209
210 BOOL copyDrive(struct drive *pSrc, struct drive *pDst)
211 {
212     if(pDst->in_use)
213     {
214         WINE_TRACE("pDst already in use\n");
215         return FALSE;
216     }
217
218     if(!pSrc->unixpath) WINE_TRACE("!pSrc->unixpath\n");
219     if(!pSrc->label) WINE_TRACE("!pSrc->label\n");
220     if(!pSrc->serial) WINE_TRACE("!pSrc->serial\n");
221
222     pDst->unixpath = strdupA(pSrc->unixpath);
223     pDst->label = strdupA(pSrc->label);
224     pDst->serial = strdupA(pSrc->serial);
225     pDst->type = pSrc->type;
226     pDst->in_use = TRUE;
227
228     return TRUE;
229 }
230
231 BOOL moveDrive(struct drive *pSrc, struct drive *pDst)
232 {
233     WINE_TRACE("pSrc->letter == %c, pDst->letter == %c\n", pSrc->letter, pDst->letter);
234
235     if(!copyDrive(pSrc, pDst))
236     {
237         WINE_TRACE("copyDrive failed\n");
238         return FALSE;
239     }
240
241     delete_drive(pSrc);
242     return TRUE;
243 }
244
245 #endif
246
247 static HANDLE open_mountmgr(void)
248 {
249     HANDLE ret;
250
251     if ((ret = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ|GENERIC_WRITE,
252                             FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
253                             0, 0 )) == INVALID_HANDLE_VALUE)
254         WINE_ERR( "failed to open mount manager err %u\n", GetLastError() );
255     return ret;
256 }
257
258 /* Load currently defined drives into the drives array  */
259 BOOL load_drives(void)
260 {
261     DWORD i, size = 1024;
262     HANDLE mgr;
263     WCHAR root[] = {'A',':','\\',0};
264
265     if ((mgr = open_mountmgr()) == INVALID_HANDLE_VALUE) return FALSE;
266
267     while (root[0] <= 'Z')
268     {
269         struct mountmgr_unix_drive input;
270         struct mountmgr_unix_drive *data;
271
272         if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) break;
273
274         memset( &input, 0, sizeof(input) );
275         input.letter = root[0];
276
277         if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE, &input, sizeof(input),
278                              data, size, NULL, NULL ))
279         {
280             char *unixpath = NULL, *device = NULL;
281             WCHAR volname[MAX_PATH];
282             DWORD serial;
283
284             if (data->mount_point_offset) unixpath = (char *)data + data->mount_point_offset;
285             if (data->device_offset) device = (char *)data + data->device_offset;
286
287             if (!GetVolumeInformationW( root, volname, sizeof(volname)/sizeof(WCHAR),
288                                         &serial, NULL, NULL, NULL, 0 ))
289             {
290                 volname[0] = 0;
291                 serial = 0;
292             }
293             if (unixpath)  /* FIXME: handle unmounted drives too */
294                 add_drive( root[0], unixpath, device, volname, serial, get_drive_type(root[0]) );
295             root[0]++;
296         }
297         else
298         {
299             if (GetLastError() == ERROR_MORE_DATA) size = data->size;
300             else root[0]++;  /* skip this drive */
301         }
302         HeapFree( GetProcessHeap(), 0, data );
303     }
304
305     /* reset modified flags */
306     for (i = 0; i < 26; i++) drives[i].modified = FALSE;
307
308     CloseHandle( mgr );
309     return TRUE;
310 }
311
312 /* some of this code appears to be broken by bugs in Wine: the label
313  * setting code has no effect, for instance  */
314 void apply_drive_changes(void)
315 {
316     int i;
317     HANDLE mgr;
318     DWORD len;
319     struct mountmgr_unix_drive *ioctl;
320
321     WINE_TRACE("\n");
322
323     if ((mgr = open_mountmgr()) == INVALID_HANDLE_VALUE) return;
324
325     /* add each drive and remove as we go */
326     for(i = 0; i < 26; i++)
327     {
328         if (!drives[i].modified) continue;
329         drives[i].modified = FALSE;
330
331         len = sizeof(*ioctl);
332         if (drives[i].in_use)
333         {
334             len += strlen(drives[i].unixpath) + 1;
335             if (drives[i].device) len += strlen(drives[i].device) + 1;
336         }
337         if (!(ioctl = HeapAlloc( GetProcessHeap(), 0, len ))) continue;
338         ioctl->size = len;
339         ioctl->letter = 'a' + i;
340         ioctl->device_offset = 0;
341         if (drives[i].in_use)
342         {
343             char *ptr = (char *)(ioctl + 1);
344
345             ioctl->type = drives[i].type;
346             strcpy( ptr, drives[i].unixpath );
347             ioctl->mount_point_offset = ptr - (char *)ioctl;
348             if (drives[i].device)
349             {
350                 ptr += strlen(ptr) + 1;
351                 strcpy( ptr, drives[i].device );
352                 ioctl->device_offset = ptr - (char *)ioctl;
353             }
354         }
355         else
356         {
357             ioctl->type = DRIVE_NO_ROOT_DIR;
358             ioctl->mount_point_offset = 0;
359         }
360
361         if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_DEFINE_UNIX_DRIVE, ioctl, len, NULL, 0, NULL, NULL ))
362         {
363             set_drive_label( drives[i].letter, drives[i].label );
364             if (drives[i].in_use) set_drive_serial( drives[i].letter, drives[i].serial );
365             WINE_TRACE( "set drive %c: to %s type %u\n", 'a' + i,
366                         wine_dbgstr_a(drives[i].unixpath), drives[i].type );
367         }
368         else WINE_WARN( "failed to set drive %c: to %s type %u err %u\n", 'a' + i,
369                        wine_dbgstr_a(drives[i].unixpath), drives[i].type, GetLastError() );
370     }
371     CloseHandle( mgr );
372 }