ROX-Filer/src/mount.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2003, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* mount.c - code for handling mount points */
  23
  24 #include "config.h"
  25 #include <stdio.h>
  26 #include <string.h>
  27 #ifdef HAVE_FCNTL_H
  28 #include <fcntl.h>
  29 #endif
  30 #ifdef HAVE_MNTENT_H
  31   /* Linux, etc */
  32 # include <mntent.h>
  33 #elif HAVE_SYS_UCRED_H
  34   /* NetBSD, OSF1, etc */
  35 # include <fstab.h>
  36 # include <sys/types.h>
  37 # include <sys/param.h>
  38 # include <sys/ucred.h>
  39 # include <sys/mount.h>
  40 # include <stdlib.h>
  41 #elif HAVE_SYS_MNTENT_H
  42   /* SunOS */
  43 # include <sys/mntent.h>
  44 # include <sys/mnttab.h>
  45 #endif
  46 #include <sys/time.h>
  47 #ifdef HAVE_STATFS
  48 #include <sys/vfs.h>
  49 #endif
  50 #ifdef HAVE_STATVFS
  51 #include <sys/statvfs.h>
  52 #endif
  53
  54 #include <gtk/gtk.h>
  55
  56 #include "global.h"
  57
  58 #include "mount.h"
  59 #include "support.h"
  60
  61 /* Map mount points to mntent structures */
  62 GHashTable *fstab_mounts = NULL;
  63 time_t fstab_time;
  64
  65 /* Keys are mount points that the user mounted. Values are ignored. */
  66 static GHashTable *user_mounts = NULL;
  67
  68 #ifdef HAVE_SYS_MNTENT_H
  69 #define THE_FSTAB VFSTAB
  70 #else
  71 #define THE_FSTAB "/etc/fstab"
  72 #endif
  73
  74 /* Static prototypes */
  75 #ifdef DO_MOUNT_POINTS
  76 static void read_table(void);
  77 static void clear_table(void);
  78 static time_t read_time(char *path);
  79 static gboolean free_mp(gpointer key, gpointer value, gpointer data);
  80 #endif
  81
  82
  83 /****************************************************************
  84  *                      EXTERNAL INTERFACE                      *
  85  ****************************************************************/
  86
  87 void mount_init(void)
  88 {
  89         fstab_mounts = g_hash_table_new(g_str_hash, g_str_equal);
  90         user_mounts = g_hash_table_new_full(g_str_hash, g_str_equal,
  91                                             g_free, NULL);
  92
  93 #ifdef DO_MOUNT_POINTS
  94         fstab_time = read_time(THE_FSTAB);
  95         read_table();
  96 #endif
  97 }
  98
  99 /* If force is true then ignore the timestamps */
 100 void mount_update(gboolean force)
 101 {
 102 #ifdef DO_MOUNT_POINTS
 103         time_t  time;
 104
 105         time = read_time(THE_FSTAB);
 106         if (force || time != fstab_time)
 107         {
 108                 fstab_time = time;
 109                 read_table();
 110         }
 111 #endif /* DO_MOUNT_POINTS */
 112 }
 113
 114 /* The user has just finished mounting/unmounting this path.
 115  * Update the list of user-mounted filesystems.
 116  */
 117 void mount_user_mount(const char *path)
 118 {
 119         if (mount_is_mounted(path, NULL, NULL))
 120                 g_hash_table_insert(user_mounts, pathdup(path), "yes");
 121         else
 122                 g_hash_table_remove(user_mounts, path);
 123 }
 124
 125 /* TRUE iff this directory is a mount point. Uses python's method to
 126  * check:
 127  * The function checks whether path's parent, path/.., is on a different device
 128  * than path, or whether path/.. and path point to the same i-node on the same
 129  * device -- this should detect mount points for all Unix and POSIX variants.
 130  *
 131  * 'info' and 'parent' are both optional, saving one stat() each.
 132  */
 133 gboolean mount_is_mounted(const guchar *path, struct stat *info,
 134                                               struct stat *parent)
 135 {
 136         struct stat info_path, info_parent;
 137
 138         if (!info)
 139         {
 140                 info = &info_path;
 141                 if (stat(path, &info_path))
 142                         return FALSE; /* Doesn't exist => not mount point :-) */
 143         }
 144
 145         if (!parent)
 146         {
 147                 guchar *tmp;
 148                 parent = &info_parent;
 149                 tmp = g_strconcat(path, "/..", NULL);
 150                 if (stat(tmp, &info_parent))
 151                 {
 152                         g_free(tmp);
 153                         return FALSE;
 154                 }
 155                 g_free(tmp);
 156         }
 157
 158         if (info->st_dev != parent->st_dev)
 159                 return TRUE;
 160
 161         if (info->st_ino == parent->st_ino)
 162                 return TRUE;    /* Same device and inode */
 163
 164         return FALSE;
 165 }
 166
 167 /* TRUE if this mount point was mounted by the user, and still is */
 168 gboolean mount_is_user_mounted(const gchar *path)
 169 {
 170         gboolean retval;
 171         gchar *real;
 172
 173         real = pathdup(path);
 174
 175         retval = g_hash_table_lookup(user_mounts, path) != NULL;
 176
 177         if (retval)
 178         {
 179                 /* Check the status is up-to-date */
 180                 mount_user_mount(real);
 181                 retval = g_hash_table_lookup(user_mounts, path) != NULL;
 182         }
 183
 184         g_free(real);
 185
 186         return retval;
 187 }
 188
 189 /****************************************************************
 190  *                      INTERNAL FUNCTIONS                      *
 191  ****************************************************************/
 192
 193
 194 #ifdef DO_MOUNT_POINTS
 195
 196 static gboolean free_mp(gpointer key, gpointer value, gpointer data)
 197 {
 198         MountPoint      *mp = (MountPoint *) value;
 199
 200         g_free(mp->name);
 201         g_free(mp->dir);
 202         g_free(mp);
 203
 204         return TRUE;
 205 }
 206
 207 /* Remove all entries from mounts table, freeing them as we go */
 208 static void clear_table(void)
 209 {
 210         g_hash_table_foreach_remove(fstab_mounts, free_mp, NULL);
 211 }
 212
 213 /* Return the mtime of a file */
 214 static time_t read_time(char *path)
 215 {
 216         struct stat info;
 217         int err = 0;
 218
 219         err = stat(path, &info);
 220
 221         g_return_val_if_fail(err == 0, 0);
 222
 223         return info.st_mtime;
 224 }
 225
 226 # ifdef HAVE_MNTENT_H
 227 static void read_table(void)
 228 {
 229         FILE            *tab;
 230         struct mntent   *ent;
 231         MountPoint      *mp;
 232 #  ifdef HAVE_FCNTL_H
 233         struct flock    lb;
 234 #  endif
 235
 236         clear_table();
 237
 238         tab = setmntent(THE_FSTAB, "r");
 239         g_return_if_fail(tab != NULL);
 240
 241 #  ifdef HAVE_FCNTL_H
 242         lb.l_type = F_RDLCK;
 243         lb.l_whence = 0;
 244         lb.l_start = 0;
 245         lb.l_len = 0;
 246         fcntl(fileno(tab), F_SETLKW, &lb);
 247 #  endif
 248
 249         while ((ent = getmntent(tab)))
 250         {
 251                 if (strcmp(ent->mnt_dir, "swap") == 0)
 252                         continue;
 253
 254                 mp = g_malloc(sizeof(MountPoint));
 255                 mp->name = g_strdup(ent->mnt_fsname);
 256                 mp->dir  = g_strdup(ent->mnt_dir);
 257
 258                 g_hash_table_insert(fstab_mounts, mp->dir, mp);
 259         }
 260
 261         endmntent(tab);
 262 }
 263
 264 # elif HAVE_SYS_MNTENT_H
 265 static void read_table(void)
 266 {
 267         FILE            *tab;
 268         struct mnttab   ent;
 269         MountPoint      *mp;
 270 #  ifdef HAVE_FCNTL_H
 271         struct flock    lb;
 272 #  endif
 273
 274         clear_table();
 275
 276         tab = fopen(THE_FSTAB, "r");
 277         g_return_if_fail(tab != NULL);
 278
 279 #  ifdef HAVE_FCNTL_H
 280         lb.l_type = F_RDLCK;
 281         lb.l_whence = 0;
 282         lb.l_start = 0;
 283         lb.l_len = 0;
 284         fcntl(fileno(tab), F_SETLKW, &lb);
 285 #  endif
 286
 287         while (getmntent(tab, &ent)==0)
 288         {
 289                 if (strcmp(ent.mnt_special, "swap") == 0)
 290                         continue;
 291
 292                 mp = g_malloc(sizeof(MountPoint));
 293                 mp->dir = g_strdup(ent.mnt_mountp);
 294                 mp->name = g_strdup(ent.mnt_special);
 295
 296                 g_hash_table_insert(fstab_mounts, mp->dir, mp);
 297         }
 298
 299         fclose(tab);
 300 }
 301
 302 # elif HAVE_SYS_UCRED_H /* We don't have getmntent(), etc */
 303
 304 static void read_table(void)
 305 {
 306         int             tab;
 307         struct fstab    *ent;
 308         MountPoint      *mp;
 309
 310         clear_table();
 311
 312         tab = setfsent();
 313         g_return_if_fail(tab != 0);
 314
 315         while ((ent = getfsent()))
 316         {
 317                 if (strcmp(ent->fs_vfstype, "swap") == 0)
 318                         continue;
 319                 if (strcmp(ent->fs_vfstype, "kernfs") == 0)
 320                         continue;
 321
 322                 mp = g_malloc(sizeof(MountPoint));
 323                 mp->name = g_strdup(ent->fs_spec);      /* block special device name */
 324                 mp->dir  = g_strdup(ent->fs_file);      /* file system path prefix */
 325
 326                 g_hash_table_insert(fstab_mounts, mp->dir, mp);
 327         }
 328
 329         endfsent();
 330 }
 331
 332 # endif /* HAVE_MNTENT_H */
 333
 334 #endif /* DO_MOUNT_POINTS */
 335
 336 gchar *mount_get_fs_size(const gchar *dir)
 337 {
 338   int ok=FALSE;
 339
 340 #if defined(HAVE_STATVFS)
 341     struct statvfs buf;
 342 #elif defined(HAVE_STATFS)
 343     struct statfs buf;
 344 #endif
 345     unsigned long long total, used, avail;
 346     gdouble fused;
 347     gchar *str;
 348     gchar *tmp1, *tmp2;
 349
 350 #if defined(HAVE_STATVFS)
 351     ok=statvfs(dir, &buf)==0;
 352 #elif defined(HAVE_STATFS)
 353     ok=statfs(dir, &buf)==0;
 354 #endif
 355     if(!ok)
 356             return NULL;
 357
 358 #if defined(HAVE_STATVFS)
 359     total=buf.f_frsize*(unsigned long long) buf.f_blocks;
 360     used=buf.f_frsize*(unsigned long long) (buf.f_blocks-buf.f_bfree);
 361     avail=buf.f_frsize*(unsigned long long) buf.f_bavail;
 362 #else
 363     total=buf.f_bsize*(unsigned long long) buf.f_blocks;
 364     used=buf.f_bsize*(unsigned long long) (buf.f_blocks-buf.f_bfree);
 365     avail=buf.f_bsize*(unsigned long long) buf.f_bavail;
 366 #endif
 367     if(total>0)
 368             fused=100.*(total-used)/((gdouble) total);
 369     else
 370             fused=0.0;
 371
 372     tmp1=g_strdup(format_size(total));
 373     tmp2=g_strdup(format_size(used));
 374     str=g_strdup_printf(_("%s total, %s used, %s free (%.1f %%)"),
 375                         tmp1, tmp2, format_size(avail), fused);
 376
 377     g_free(tmp1);
 378     g_free(tmp2);
 379
 380     return str;
 381 }
 382