1 /*
2 * Drive autodetection code
3 *
4 * Copyright 2004 Mike Hearn
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
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #ifdef HAVE_MNTENT_H
28 #include <mntent.h>
29 #endif
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <sys/stat.h>
33
34 #include <windef.h>
35 #include <winbase.h>
36 #include <wine/debug.h>
37 #include <wine/library.h>
38
39 #include "winecfg.h"
40 #include "resource.h"
41
42
43 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
44
45 BOOL gui_mode = TRUE;
46 static ULONG working_mask = 0;
47
48 typedef struct
49 {
50 const char *szNode;
51 int nType;
52 } DEV_NODES;
53
54 #ifdef HAVE_MNTENT_H
55
56 static const DEV_NODES sDeviceNodes[] = {
57 {"/dev/fd", DRIVE_REMOVABLE},
58 {"/dev/pf", DRIVE_REMOVABLE},
59 {"/dev/acd", DRIVE_CDROM},
60 {"/dev/aztcd", DRIVE_CDROM},
61 {"/dev/bpcd", DRIVE_CDROM},
62 {"/dev/cd", DRIVE_CDROM},
63 {"/dev/cdrom", DRIVE_CDROM},
64 {"/dev/cdu535", DRIVE_CDROM},
65 {"/dev/cdwriter", DRIVE_CDROM},
66 {"/dev/cm205cd", DRIVE_CDROM},
67 {"/dev/cm206cd", DRIVE_CDROM},
68 {"/dev/gscd", DRIVE_CDROM},
69 {"/dev/hitcd", DRIVE_CDROM},
70 {"/dev/iseries/vcd", DRIVE_CDROM},
71 {"/dev/lmscd", DRIVE_CDROM},
72 {"/dev/mcd", DRIVE_CDROM},
73 {"/dev/optcd", DRIVE_CDROM},
74 {"/dev/pcd", DRIVE_CDROM},
75 {"/dev/sbpcd", DRIVE_CDROM},
76 {"/dev/scd", DRIVE_CDROM},
77 {"/dev/sjcd", DRIVE_CDROM},
78 {"/dev/sonycd", DRIVE_CDROM},
79 {"/dev/sr", DRIVE_CDROM},
80 {"",0}
81 };
82
83 static const char * const ignored_fstypes[] = {
84 "devpts",
85 "tmpfs",
86 "proc",
87 "sysfs",
88 "swap",
89 "usbdevfs",
90 "rpc_pipefs",
91 "binfmt_misc",
92 NULL
93 };
94
95 static const char * const ignored_mnt_dirs[] = {
96 "/boot",
97 NULL
98 };
99
100 static int try_dev_node(char *dev)
101 {
102 const DEV_NODES *pDevNodes = sDeviceNodes;
103
104 while(pDevNodes->szNode[0])
105 {
106 if(!strncmp(dev,pDevNodes->szNode,strlen(pDevNodes->szNode)))
107 return pDevNodes->nType;
108 ++pDevNodes;
109 }
110
111 return DRIVE_FIXED;
112 }
113
114 static BOOL should_ignore_fstype(char *type)
115 {
116 const char * const *s;
117
118 for (s = ignored_fstypes; *s; s++)
119 if (!strcmp(*s, type)) return TRUE;
120
121 return FALSE;
122 }
123
124 static BOOL should_ignore_mnt_dir(char *dir)
125 {
126 const char * const *s;
127
128 for (s = ignored_mnt_dirs; *s; s++)
129 if (!strcmp(*s, dir)) return TRUE;
130
131 return FALSE;
132 }
133
134 static BOOL is_drive_defined(char *path)
135 {
136 int i;
137
138 for (i = 0; i < 26; i++)
139 if (drives[i].in_use && !strcmp(drives[i].unixpath, path)) return TRUE;
140
141 return FALSE;
142 }
143
144 /* returns Z + 1 if there are no more available letters */
145 static char allocate_letter(int type)
146 {
147 char letter, start;
148
149 if (type == DRIVE_REMOVABLE)
150 start = 'A';
151 else
152 start = 'C';
153
154 for (letter = start; letter <= 'Z'; letter++)
155 if ((DRIVE_MASK_BIT(letter) & working_mask) != 0) break;
156
157 return letter;
158 }
159 #endif
160
161 #define FSTAB_OPEN 1
162 #define NO_MORE_LETTERS 2
163 #define NO_ROOT 3
164 #define NO_DRIVE_C 4
165 #define NO_HOME 5
166
167 static void report_error(int code)
168 {
169 char *buffer;
170 int len;
171
172 switch (code)
173 {
174 case FSTAB_OPEN:
175 if (gui_mode)
176 {
177 static const char s[] = "Could not open your mountpoint description table.\n\nOpening of /etc/fstab failed: %s";
178 len = snprintf(NULL, 0, s, strerror(errno));
179 buffer = HeapAlloc(GetProcessHeap(), 0, len + 1);
180 snprintf(buffer, len, s, strerror(errno));
181 MessageBox(NULL, s, "", MB_OK | MB_ICONEXCLAMATION);
182 HeapFree(GetProcessHeap(), 0, buffer);
183 }
184 else
185 {
186 fprintf(stderr, "winecfg: could not open fstab: %s\n", strerror(errno));
187 }
188 break;
189
190 case NO_MORE_LETTERS:
191 if (gui_mode) MessageBox(NULL, "No more letters are available to auto-detect available drives with.", "", MB_OK | MB_ICONEXCLAMATION);
192 fprintf(stderr, "winecfg: no more available letters while scanning /etc/fstab\n");
193 break;
194
195 case NO_ROOT:
196 if (gui_mode) MessageBox(NULL, "Could not ensure that the root directory was mapped.\n\n"
197 "This can happen if you run out of drive letters. "
198 "It's important to have the root directory mapped, otherwise Wine"
199 "will not be able to always find the programs you want to run. "
200 "Try unmapping a drive letter then trying again.", "",
201 MB_OK | MB_ICONEXCLAMATION);
202 else fprintf(stderr, "winecfg: unable to map root drive\n");
203 break;
204
205 case NO_DRIVE_C:
206 if (gui_mode)
207 MessageBox(NULL, "No virtual drive C mapped\n\nTry running wineprefixcreate", "", MB_OK | MB_ICONEXCLAMATION);
208 else
209 fprintf(stderr, "winecfg: no drive_c directory\n");
210
211 case NO_HOME:
212 if (gui_mode)
213 MessageBox(NULL, "Could not ensure that your home directory was mapped.\n\n"
214 "This can happen if you run out of drive letters. "
215 "Try unmapping a drive letter then try again.", "",
216 MB_OK | MB_ICONEXCLAMATION);
217 else
218 fprintf(stderr, "winecfg: unable to map home drive\n");
219 break;
220 }
221 }
222
223 static void ensure_root_is_mapped(void)
224 {
225 int i;
226 BOOL mapped = FALSE;
227
228 for (i = 0; i < 26; i++)
229 if (drives[i].in_use && !strcmp(drives[i].unixpath, "/")) mapped = TRUE;
230
231 if (!mapped)
232 {
233 /* work backwards from Z, trying to map it */
234 char letter;
235
236 for (letter = 'Z'; letter >= 'A'; letter--)
237 {
238 if (!drives[letter - 'A'].in_use)
239 {
240 add_drive(letter, "/", NULL, NULL, 0, DRIVE_FIXED);
241 WINE_TRACE("allocated drive %c as the root drive\n", letter);
242 break;
243 }
244 }
245
246 if (letter == ('A' - 1)) report_error(NO_ROOT);
247 }
248 }
249
250 static void ensure_home_is_mapped(void)
251 {
252 int i;
253 BOOL mapped = FALSE;
254 char *home = getenv("HOME");
255
256 if (!home) return;
257
258 for (i = 0; i < 26; i++)
259 if (drives[i].in_use && !strcmp(drives[i].unixpath, home)) mapped = TRUE;
260
261 if (!mapped)
262 {
263 char letter;
264
265 for (letter = 'H'; letter <= 'Z'; letter++)
266 {
267 if (!drives[letter - 'A'].in_use)
268 {
269 add_drive(letter, home, NULL, NULL, 0, DRIVE_FIXED);
270 WINE_TRACE("allocated drive %c as the user's home directory\n", letter);
271 break;
272 }
273 }
274 if (letter == ('Z' + 1)) report_error(NO_HOME);
275 }
276 }
277
278 static void ensure_drive_c_is_mapped(void)
279 {
280 struct stat buf;
281 const char *configdir = wine_get_config_dir();
282 int len;
283 char *drive_c_dir;
284
285 if (drives[2].in_use) return;
286
287 len = snprintf(NULL, 0, "%s/../drive_c", configdir);
288 drive_c_dir = HeapAlloc(GetProcessHeap(), 0, len);
289 snprintf(drive_c_dir, len, "%s/../drive_c", configdir);
290 HeapFree(GetProcessHeap(), 0, drive_c_dir);
291
292 if (stat(drive_c_dir, &buf) == 0)
293 {
294 WCHAR label[64];
295 LoadStringW (GetModuleHandle (NULL), IDS_SYSTEM_DRIVE_LABEL, label,
296 sizeof(label)/sizeof(label[0]));
297 add_drive('C', "../drive_c", NULL, label, 0, DRIVE_FIXED);
298 }
299 else
300 {
301 report_error(NO_DRIVE_C);
302 }
303 }
304
305 int autodetect_drives(void)
306 {
307 #ifdef HAVE_MNTENT_H
308 struct mntent *ent;
309 FILE *fstab;
310 #endif
311
312 /* we want to build a list of autodetected drives, then ensure each entry
313 exists in the users setup. so, we superimpose the autodetected drives
314 onto whatever is pre-existing.
315
316 for now let's just rummage around inside the fstab.
317 */
318
319 load_drives();
320
321 working_mask = drive_available_mask('\0');
322
323 #ifdef HAVE_MNTENT_H
324 fstab = fopen("/etc/fstab", "r");
325 if (!fstab)
326 {
327 report_error(FSTAB_OPEN);
328 return FALSE;
329 }
330
331 while ((ent = getmntent(fstab)))
332 {
333 char letter;
334 int type;
335 char *device = NULL;
336
337 WINE_TRACE("ent->mnt_dir=%s\n", ent->mnt_dir);
338
339 if (should_ignore_fstype(ent->mnt_type)) continue;
340 if (should_ignore_mnt_dir(ent->mnt_dir)) continue;
341 if (is_drive_defined(ent->mnt_dir)) continue;
342
343 if (!strcmp(ent->mnt_type, "nfs")) type = DRIVE_REMOTE;
344 else if (!strcmp(ent->mnt_type, "nfs4")) type = DRIVE_REMOTE;
345 else if (!strcmp(ent->mnt_type, "smbfs")) type = DRIVE_REMOTE;
346 else if (!strcmp(ent->mnt_type, "cifs")) type = DRIVE_REMOTE;
347 else if (!strcmp(ent->mnt_type, "coda")) type = DRIVE_REMOTE;
348 else if (!strcmp(ent->mnt_type, "iso9660")) type = DRIVE_CDROM;
349 else if (!strcmp(ent->mnt_type, "ramfs")) type = DRIVE_RAMDISK;
350 else type = try_dev_node(ent->mnt_fsname);
351
352 /* allocate a drive for it */
353 letter = allocate_letter(type);
354 if (letter == 'Z' + 1)
355 {
356 report_error(NO_MORE_LETTERS);
357 fclose(fstab);
358 return FALSE;
359 }
360
361 if (type == DRIVE_CDROM) device = ent->mnt_fsname;
362
363 WINE_TRACE("adding drive %c for %s, device %s, type %s\n",
364 letter, ent->mnt_dir, device, ent->mnt_type);
365 add_drive(letter, ent->mnt_dir, device, NULL, 0, type);
366
367 /* working_mask is a map of the drive letters still available. */
368 working_mask &= ~DRIVE_MASK_BIT(letter);
369 }
370
371 fclose(fstab);
372 #endif
373
374 ensure_root_is_mapped();
375
376 ensure_drive_c_is_mapped();
377
378 ensure_home_is_mapped();
379
380 return TRUE;
381 }
382
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.