git.oblomov.eu Git - wine/blob - programs/winecfg/drivedetect.c

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include <wine/debug.h>
  23 #include <wine/library.h>
  24
  25 #include "winecfg.h"
  26
  27 #include <stdio.h>
  28 #ifdef HAVE_MNTENT_H
  29 #include <mntent.h>
  30 #endif
  31 #include <stdlib.h>
  32 #include <errno.h>
  33
  34 #include <sys/stat.h>
  35
  36 #include <winbase.h>
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(winecfg);
  39
  40 BOOL gui_mode = TRUE;
  41 static long working_mask = 0;
  42
  43 #ifdef HAVE_MNTENT_H
  44 static char *ignored_fstypes[] = {
  45     "devpts",
  46     "tmpfs",
  47     "proc",
  48     "sysfs",
  49     "swap",
  50     "usbdevfs",
  51     "rpc_pipefs",
  52     NULL
  53 };
  54
  55 static BOOL should_ignore_fstype(char *type)
  56 {
  57     char **s;
  58
  59     for (s = ignored_fstypes; *s; s++)
  60         if (!strcmp(*s, type)) return TRUE;
  61
  62     return FALSE;
  63 }
  64
  65 static BOOL is_drive_defined(char *path)
  66 {
  67     int i;
  68
  69     for (i = 0; i < 26; i++)
  70         if (drives[i].in_use && !strcmp(drives[i].unixpath, path)) return TRUE;
  71
  72     return FALSE;
  73 }
  74
  75 /* returns Z + 1 if there are no more available letters */
  76 static char allocate_letter()
  77 {
  78     char letter;
  79
  80     for (letter = 'C'; letter <= 'Z'; letter++)
  81         if ((DRIVE_MASK_BIT(letter) & working_mask) != 0) break;
  82
  83     return letter;
  84 }
  85 #endif
  86
  87 #define FSTAB_OPEN 1
  88 #define NO_MORE_LETTERS 2
  89 #define NO_ROOT 3
  90 #define NO_DRIVE_C 4
  91
  92 static void report_error(int code)
  93 {
  94     char *buffer;
  95     int len;
  96
  97     switch (code)
  98     {
  99         case FSTAB_OPEN:
 100             if (gui_mode)
 101             {
 102                 static const char *s = "Could not open your mountpoint description table.\n\nOpening of /etc/fstab failed: %s";
 103                 len = snprintf(NULL, 0, s, strerror(errno));
 104                 buffer = HeapAlloc(GetProcessHeap(), 0, len + 1);
 105                 snprintf(buffer, len, s, strerror(errno));
 106                 MessageBox(NULL, s, "", MB_OK | MB_ICONEXCLAMATION);
 107                 HeapFree(GetProcessHeap(), 0, buffer);
 108             }
 109             else
 110             {
 111                 fprintf(stderr, "winecfg: could not open fstab: %s", strerror(errno));
 112             }
 113             break;
 114
 115         case NO_MORE_LETTERS:
 116             if (gui_mode) MessageBox(NULL, "No more letters are available to auto-detect available drives with.", "", MB_OK | MB_ICONEXCLAMATION);
 117             fprintf(stderr, "winecfg: no more available letters while scanning /etc/fstab");
 118             break;
 119
 120         case NO_ROOT:
 121             if (gui_mode) MessageBox(NULL, "Could not ensure that the root directory was mapped.\n\n"
 122                                      "This can happen if you run out of drive letters. "
 123                                      "It's important to have the root directory mapped, otherwise Wine"
 124                                      "will not be able to always find the programs you want to run. "
 125                                      "Try unmapping a drive letter then trying again.", "",
 126                                      MB_OK | MB_ICONEXCLAMATION);
 127             else fprintf(stderr, "winecfg: unable to map root drive\n");
 128             break;
 129
 130         case NO_DRIVE_C:
 131             if (gui_mode)
 132                 MessageBox(NULL, "No virtual drive C mapped\n\nTry running wineprefixcreate", "", MB_OK | MB_ICONEXCLAMATION);
 133             else
 134                 fprintf(stderr, "winecfg: no drive_c directory\n");
 135     }
 136
 137 }
 138
 139 static void ensure_root_is_mapped()
 140 {
 141     int i;
 142     BOOL mapped = FALSE;
 143
 144     for (i = 0; i < 26; i++)
 145         if (drives[i].in_use && !strcmp(drives[i].unixpath, "/")) mapped = TRUE;
 146
 147     if (!mapped)
 148     {
 149         /* work backwards from Z, trying to map it */
 150         char letter;
 151
 152         for (letter = 'Z'; letter >= 'A'; letter--)
 153         {
 154             if (drives[letter - 'A'].in_use) continue;
 155             add_drive(letter, "/", "System", 0, DRIVE_FIXED);
 156             WINE_TRACE("allocated drive %c as the root drive\n", letter);
 157         }
 158
 159         if (letter == ('A' - 1)) report_error(NO_ROOT);
 160     }
 161 }
 162
 163 static void ensure_drive_c_is_mapped()
 164 {
 165     struct stat buf;
 166     const char *configdir = wine_get_config_dir();
 167     int len;
 168     char *drive_c_dir;
 169
 170     if (drives[2].in_use) return;
 171
 172     len = snprintf(NULL, 0, "%s/../drive_c", configdir);
 173     drive_c_dir = HeapAlloc(GetProcessHeap(), 0, len);
 174     snprintf(drive_c_dir, len, "%s/../drive_c", configdir);
 175     HeapFree(GetProcessHeap(), 0, drive_c_dir);
 176
 177     if (stat(drive_c_dir, &buf) == 0)
 178     {
 179         add_drive('C', "../drive_c", "Virtual Windows Drive", "0", DRIVE_FIXED);
 180     }
 181     else
 182     {
 183         report_error(NO_DRIVE_C);
 184     }
 185 }
 186
 187 int autodetect_drives()
 188 {
 189 #ifdef HAVE_MNTENT_H
 190     struct mntent *ent;
 191     FILE *fstab;
 192 #endif
 193
 194     /* we want to build a list of autodetected drives, then ensure each entry
 195        exists in the users setup. so, we superimpose the autodetected drives
 196        onto whatever is pre-existing.
 197
 198        for now let's just rummage around inside the fstab.
 199      */
 200
 201     load_drives();
 202
 203     working_mask = drive_available_mask('\0');
 204
 205 #ifdef HAVE_MNTENT_H
 206     fstab = fopen("/etc/fstab", "r");
 207     if (!fstab)
 208     {
 209         report_error(FSTAB_OPEN);
 210         return FALSE;
 211     }
 212
 213     while ((ent = getmntent(fstab)))
 214     {
 215         char letter;
 216         char label[256];
 217         int type;
 218
 219         WINE_TRACE("ent->mnt_dir=%s\n", ent->mnt_dir);
 220
 221         if (should_ignore_fstype(ent->mnt_type)) continue;
 222         if (is_drive_defined(ent->mnt_dir)) continue;
 223
 224         /* allocate a drive for it */
 225         letter = allocate_letter();
 226         if (letter == ']')
 227         {
 228             report_error(NO_MORE_LETTERS);
 229             fclose(fstab);
 230             return FALSE;
 231         }
 232
 233         WINE_TRACE("adding drive %c for %s, type %s\n", letter, ent->mnt_dir, ent->mnt_type);
 234
 235         strncpy(label, "Drive X", 8);
 236         label[6] = letter;
 237
 238         if (!strcmp(ent->mnt_type, "nfs")) type = DRIVE_REMOTE;
 239         else if (!strcmp(ent->mnt_type, "nfs4")) type = DRIVE_REMOTE;
 240         else if (!strcmp(ent->mnt_type, "smbfs")) type = DRIVE_REMOTE;
 241         else if (!strcmp(ent->mnt_type, "cifs")) type = DRIVE_REMOTE;
 242         else if (!strcmp(ent->mnt_type, "coda")) type = DRIVE_REMOTE;
 243         else if (!strcmp(ent->mnt_type, "iso9660")) type = DRIVE_CDROM;
 244         else if (!strcmp(ent->mnt_type, "ramfs")) type = DRIVE_RAMDISK;
 245         else type = DRIVE_FIXED;
 246
 247         add_drive(letter, ent->mnt_dir, label, "0", type);
 248
 249         working_mask |= DRIVE_MASK_BIT(letter);
 250     }
 251
 252     fclose(fstab);
 253 #endif
 254
 255     ensure_root_is_mapped();
 256
 257     ensure_drive_c_is_mapped();
 258
 259     return TRUE;
 260 }