winecfg: Fixed reading in colour data from a theme file.
[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 <windef.h>
33 #include <winbase.h>
34 #include <winreg.h>
35 #include <wine/debug.h>
36 #include <shellapi.h>
37 #include <objbase.h>
38 #include <shlguid.h>
39 #include <shlwapi.h>
40 #include <shlobj.h>
41 #include <wine/library.h>
42
43 #include "winecfg.h"
44 #include "resource.h"
45
46
47 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
48
49 struct drive drives[26]; /* one for each drive letter */
50
51 static inline int letter_to_index(char letter)
52 {
53     return (toupper(letter) - 'A');
54 }
55
56 /* This function produces a mask for each drive letter that isn't
57  * currently used. Each bit of the long result represents a letter,
58  * with A being the least significant bit, and Z being the most
59  * significant.
60  *
61  * To calculate this, we loop over each letter, and see if we can get
62  * a drive entry for it. If so, we set the appropriate bit. At the
63  * end, we flip each bit, to give the desired result.
64  *
65  * The letter parameter is always marked as being available. This is
66  * so the edit dialog can display the currently used drive letter
67  * alongside the available ones.
68  */
69 long drive_available_mask(char letter)
70 {
71   long result = 0;
72   int i;
73
74   WINE_TRACE("\n");
75
76
77   for(i = 0; i < 26; i++)
78   {
79       if (!drives[i].in_use) continue;
80       result |= (1 << (letter_to_index(drives[i].letter)));
81   }
82
83   result = ~result;
84   if (letter) result |= DRIVE_MASK_BIT(letter);
85
86   WINE_TRACE("finished drive letter loop with %lx\n", result);
87   return result;
88 }
89
90 BOOL add_drive(const char letter, const char *targetpath, const char *label, const char *serial, unsigned int type)
91 {
92     int driveIndex = letter_to_index(letter);
93
94     if(drives[driveIndex].in_use)
95         return FALSE;
96
97     WINE_TRACE("letter == '%c', unixpath == '%s', label == '%s', serial == '%s', type == %d\n",
98                letter, targetpath, label, serial, type);
99
100     drives[driveIndex].letter   = toupper(letter);
101     drives[driveIndex].unixpath = strdupA(targetpath);
102     drives[driveIndex].label    = strdupA(label);
103     drives[driveIndex].serial   = strdupA(serial);
104     drives[driveIndex].type     = type;
105     drives[driveIndex].in_use   = TRUE;
106
107     return TRUE;
108 }
109
110 /* deallocates the contents of the drive. does not free the drive itself  */
111 void delete_drive(struct drive *d)
112 {
113     HeapFree(GetProcessHeap(), 0, d->unixpath);
114     d->unixpath = NULL;
115     HeapFree(GetProcessHeap(), 0, d->label);
116     d->label = NULL;
117     HeapFree(GetProcessHeap(), 0, d->serial);
118     d->serial = NULL;
119
120     d->in_use = FALSE;
121 }
122
123 static void set_drive_type( char letter, DWORD type )
124 {
125     HKEY hKey;
126     char driveValue[4];
127     const char *typeText = NULL;
128
129     sprintf(driveValue, "%c:", letter);
130
131     /* Set the drive type in the registry */
132     if (type == DRIVE_FIXED)
133         typeText = "hd";
134     else if (type == DRIVE_REMOTE)
135         typeText = "network";
136     else if (type == DRIVE_REMOVABLE)
137         typeText = "floppy";
138     else if (type == DRIVE_CDROM)
139         typeText = "cdrom";
140
141     if (RegCreateKey(HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hKey) != ERROR_SUCCESS)
142         WINE_TRACE("  Unable to open '%s'\n", "Software\\Wine\\Drives");
143     else
144     {
145         if (typeText)
146             RegSetValueEx( hKey, driveValue, 0, REG_SZ, (const BYTE *)typeText, strlen(typeText) + 1 );
147         else
148             RegDeleteValue( hKey, driveValue );
149         RegCloseKey(hKey);
150     }
151 }
152
153 static DWORD get_drive_type( char letter )
154 {
155     HKEY hKey;
156     char driveValue[4];
157     DWORD ret = DRIVE_UNKNOWN;
158
159     sprintf(driveValue, "%c:", letter);
160
161     if (RegOpenKey(HKEY_LOCAL_MACHINE, "Software\\Wine\\Drives", &hKey) != ERROR_SUCCESS)
162         WINE_TRACE("  Unable to open Software\\Wine\\Drives\n" );
163     else
164     {
165         char buffer[80];
166         DWORD size = sizeof(buffer);
167
168         if (!RegQueryValueExA( hKey, driveValue, NULL, NULL, (LPBYTE)buffer, &size ))
169         {
170             WINE_TRACE("Got type '%s' for %s\n", buffer, driveValue );
171             if (!lstrcmpi( buffer, "hd" )) ret = DRIVE_FIXED;
172             else if (!lstrcmpi( buffer, "network" )) ret = DRIVE_REMOTE;
173             else if (!lstrcmpi( buffer, "floppy" )) ret = DRIVE_REMOVABLE;
174             else if (!lstrcmpi( buffer, "cdrom" )) ret = DRIVE_CDROM;
175         }
176         RegCloseKey(hKey);
177     }
178     return ret;
179 }
180
181
182 static void set_drive_label( char letter, const char *label )
183 {
184     char device[] = "a:\\";  /* SetVolumeLabel() requires a trailing slash */
185     device[0] = letter;
186
187     if(!SetVolumeLabel(device, label))
188     {
189         WINE_WARN("unable to set volume label for devicename of '%s', label of '%s'\n",
190                   device, label);
191         PRINTERROR();
192     }
193     else
194     {
195         WINE_TRACE("  set volume label for devicename of '%s', label of '%s'\n",
196                    device, label);
197     }
198 }
199
200 /* set the drive serial number via a .windows-serial file */
201 static void set_drive_serial( char letter, const char *serial )
202 {
203     char filename[] = "a:\\.windows-serial";
204     HANDLE hFile;
205
206     filename[0] = letter;
207     WINE_TRACE("Putting serial number of '%s' into file '%s'\n", serial, filename);
208     hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
209                        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
210     if (hFile != INVALID_HANDLE_VALUE)
211     {
212         DWORD w;
213         WriteFile(hFile, serial, strlen(serial), &w, NULL);
214         WriteFile(hFile, "\n", 1, &w, NULL);
215         CloseHandle(hFile);
216     }
217 }
218
219 #if 0
220
221 /* currently unused, but if users have this burning desire to be able to rename drives,
222    we can put it back in.
223  */
224
225 BOOL copyDrive(struct drive *pSrc, struct drive *pDst)
226 {
227     if(pDst->in_use)
228     {
229         WINE_TRACE("pDst already in use\n");
230         return FALSE;
231     }
232
233     if(!pSrc->unixpath) WINE_TRACE("!pSrc->unixpath\n");
234     if(!pSrc->label) WINE_TRACE("!pSrc->label\n");
235     if(!pSrc->serial) WINE_TRACE("!pSrc->serial\n");
236
237     pDst->unixpath = strdupA(pSrc->unixpath);
238     pDst->label = strdupA(pSrc->label);
239     pDst->serial = strdupA(pSrc->serial);
240     pDst->type = pSrc->type;
241     pDst->in_use = TRUE;
242
243     return TRUE;
244 }
245
246 BOOL moveDrive(struct drive *pSrc, struct drive *pDst)
247 {
248     WINE_TRACE("pSrc->letter == %c, pDst->letter == %c\n", pSrc->letter, pDst->letter);
249
250     if(!copyDrive(pSrc, pDst))
251     {
252         WINE_TRACE("copyDrive failed\n");
253         return FALSE;
254     }
255
256     delete_drive(pSrc);
257     return TRUE;
258 }
259
260 #endif
261
262 /* Load currently defined drives into the drives array  */
263 void load_drives(void)
264 {
265     char *devices, *dev;
266     int len;
267     int drivecount = 0, i;
268     int retval;
269     static const int arraysize = 512;
270     const char *config_dir = wine_get_config_dir();
271     char *path;
272
273     WINE_TRACE("\n");
274
275     /* setup the drives array */
276     dev = devices = HeapAlloc(GetProcessHeap(), 0, arraysize);
277     len = GetLogicalDriveStrings(arraysize, devices);
278
279     /* make all devices unused */
280     for (i = 0; i < 26; i++)
281     {
282         drives[i].letter = 'A' + i;
283         drives[i].in_use = FALSE;
284
285         HeapFree(GetProcessHeap(), 0, drives[i].unixpath);
286         drives[i].unixpath = NULL;
287
288         HeapFree(GetProcessHeap(), 0, drives[i].label);
289         drives[i].label = NULL;
290
291         HeapFree(GetProcessHeap(), 0, drives[i].serial);
292         drives[i].serial = NULL;
293     }
294
295     /* work backwards through the result of GetLogicalDriveStrings  */
296     while (len)
297     {
298         char volname[512]; /* volume name  */
299         DWORD serial;
300         char serialstr[256];
301         char rootpath[256];
302         char simplepath[3];
303         int pathlen;
304         char targetpath[256];
305         char *c;
306
307         *devices = toupper(*devices);
308
309         WINE_TRACE("devices == '%s'\n", devices);
310
311         volname[0] = 0;
312
313         retval = GetVolumeInformation(devices,
314                                       volname,
315                                       sizeof(volname),
316                                       &serial,
317                                       NULL,
318                                       NULL,
319                                       NULL,
320                                       0);
321         if(!retval)
322         {
323             WINE_ERR("GetVolumeInformation() for '%s' failed, setting serial to 0\n", devices);
324             PRINTERROR();
325             serial = 0;
326         }
327
328         WINE_TRACE("serial: '0x%X'\n", serial);
329
330         /* build rootpath for GetDriveType() */
331         lstrcpynA(rootpath, devices, sizeof(rootpath));
332         pathlen = strlen(rootpath);
333
334         /* ensure that we have a backslash on the root path */
335         if ((rootpath[pathlen - 1] != '\\') && (pathlen < sizeof(rootpath)))
336         {
337             rootpath[pathlen] = '\\';
338             rootpath[pathlen + 1] = 0;
339         }
340
341         /* QueryDosDevice() requires no trailing backslash */
342         lstrcpynA(simplepath, devices, 3);
343         QueryDosDevice(simplepath, targetpath, sizeof(targetpath));
344
345         /* targetpath may have forward slashes rather than backslashes, so correct */
346         c = targetpath;
347         do if (*c == '\\') *c = '/'; while (*c++);
348
349         snprintf(serialstr, sizeof(serialstr), "%X", serial);
350         WINE_TRACE("serialstr: '%s'\n", serialstr);
351         add_drive(*devices, targetpath, volname, serialstr, get_drive_type(devices[0]) );
352
353         len -= strlen(devices);
354         devices += strlen(devices);
355
356         /* skip over any nulls */
357         while ((*devices == 0) && (len))
358         {
359             len--;
360             devices++;
361         }
362
363         drivecount++;
364     }
365
366     /* Find all the broken symlinks we might have and add them as well. */
367
368     len = strlen(config_dir) + sizeof("/dosdevices/a:");
369     if (!(path = HeapAlloc(GetProcessHeap(), 0, len)))
370         return;
371
372     strcpy(path, config_dir);
373     strcat(path, "/dosdevices/a:");
374
375     for (i = 0; i < 26; i++)
376     {
377         char buff[MAX_PATH];
378         struct stat st;
379         int cnt;
380
381         if (drives[i].in_use) continue;
382         path[len - 3] = 'a' + i;
383
384         if (lstat(path, &st) == -1 || !S_ISLNK(st.st_mode)) continue;
385         if ((cnt = readlink(path, buff, sizeof(buff))) == -1) continue;
386         buff[cnt] = '\0';
387
388         WINE_TRACE("found broken symlink %s -> %s\n", path, buff);
389         add_drive('A' + i, buff, "", "0", DRIVE_UNKNOWN);
390
391         drivecount++;
392     }
393
394     WINE_TRACE("found %d drives\n", drivecount);
395
396     HeapFree(GetProcessHeap(), 0, path);
397     HeapFree(GetProcessHeap(), 0, dev);
398 }
399
400 /* some of this code appears to be broken by bugs in Wine: the label
401  * setting code has no effect, for instance  */
402 void apply_drive_changes(void)
403 {
404     int i;
405     CHAR devicename[4];
406     CHAR targetpath[256];
407     BOOL foundDrive;
408     CHAR volumeNameBuffer[512];
409     DWORD serialNumber;
410     DWORD maxComponentLength;
411     DWORD fileSystemFlags;
412     CHAR fileSystemName[128];
413     char newSerialNumberText[32];
414     int retval;
415     BOOL defineDevice;
416
417     WINE_TRACE("\n");
418
419     /* add each drive and remove as we go */
420     for(i = 0; i < 26; i++)
421     {
422         defineDevice = FALSE;
423         foundDrive = FALSE;
424         volumeNameBuffer[0] = 0;
425         serialNumber = 0;
426         snprintf(devicename, sizeof(devicename), "%c:", 'A' + i);
427
428         /* get a drive */
429         if(QueryDosDevice(devicename, targetpath, sizeof(targetpath)))
430         {
431             char *cursor;
432             
433             /* correct the slashes in the path to be UNIX style */
434             while ((cursor = strchr(targetpath, '\\'))) *cursor = '/';
435
436             foundDrive = TRUE;
437         }
438
439         /* if we found a drive and have a drive then compare things */
440         if(foundDrive && drives[i].in_use)
441         {
442             WINE_TRACE("drives[i].letter: '%c'\n", drives[i].letter);
443
444             snprintf(devicename, sizeof(devicename), "%c:\\", 'A' + i);
445             retval = GetVolumeInformation(devicename,
446                          volumeNameBuffer,
447                          sizeof(volumeNameBuffer),
448                          &serialNumber,
449                          &maxComponentLength,
450                          &fileSystemFlags,
451                          fileSystemName,
452                          sizeof(fileSystemName));
453             if(!retval)
454             {
455                 WINE_TRACE("  GetVolumeInformation() for '%s' failed\n", devicename);
456                 PRINTERROR();
457                 volumeNameBuffer[0] = '\0';
458             }
459
460             WINE_TRACE("  current path:   '%s', new path:   '%s'\n",
461                        targetpath, drives[i].unixpath);
462
463             /* compare to what we have */
464             /* do we have the same targetpath? */
465             if(strcmp(drives[i].unixpath, targetpath))
466             {
467                 defineDevice = TRUE;
468                 WINE_TRACE("  making changes to drive '%s'\n", devicename);
469             }
470             else
471             {
472                 WINE_TRACE("  no changes to drive '%s'\n", devicename);
473             }
474         }
475         else if(foundDrive && !drives[i].in_use)
476         {
477             /* remove this drive */
478             if(!DefineDosDevice(DDD_REMOVE_DEFINITION, devicename, drives[i].unixpath))
479             {
480                 WINE_ERR("unable to remove devicename of '%s', targetpath of '%s'\n",
481                     devicename, drives[i].unixpath);
482                 PRINTERROR();
483             }
484             else
485             {
486                 WINE_TRACE("removed devicename of '%s', targetpath of '%s'\n",
487                            devicename, drives[i].unixpath);
488             }
489
490             set_drive_type( drives[i].letter, DRIVE_UNKNOWN );
491             continue;
492         }
493         else if(drives[i].in_use) /* foundDrive must be false from the above check */
494         {
495             defineDevice = TRUE;
496         }
497
498         /* adding and modifying are the same steps */
499         if(defineDevice)
500         {
501             /* define this drive */
502             /* DefineDosDevice() requires that NO trailing slash be present */
503             snprintf(devicename, sizeof(devicename), "%c:", 'A' + i);
504             if(!DefineDosDevice(DDD_RAW_TARGET_PATH, devicename, drives[i].unixpath))
505             {
506                 WINE_ERR("  unable to define devicename of '%s', targetpath of '%s'\n",
507                     devicename, drives[i].unixpath);
508                 PRINTERROR();
509             }
510             else
511             {
512                 WINE_TRACE("  added devicename of '%s', targetpath of '%s'\n",
513                            devicename, drives[i].unixpath);
514             }
515         }
516
517         if (drives[i].label && strcmp(drives[i].label, volumeNameBuffer))
518             set_drive_label( drives[i].letter, drives[i].label );
519
520         snprintf(newSerialNumberText, sizeof(newSerialNumberText), "%X", serialNumber);
521         if (drives[i].serial && drives[i].serial[0] && strcmp(drives[i].serial, newSerialNumberText))
522             set_drive_serial( drives[i].letter, drives[i].serial );
523
524         set_drive_type( drives[i].letter, drives[i].type );
525     }
526 }