src/vfs/local/local.c

   1 /*
   2    Virtual File System: local file system.
   3
   4    Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   5    2006, 2007, 2009, 2011
   6    The Free Software Foundation, Inc.
   7
   8    This file is part of the Midnight Commander.
   9
  10    The Midnight Commander is free software: you can redistribute it
  11    and/or modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation, either version 3 of the License,
  13    or (at your option) any later version.
  14
  15    The Midnight Commander is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 /**
  25  * \file
  26  * \brief Source: local FS
  27  */
  28
  29 #include <config.h>
  30 #include <errno.h>
  31 #include <sys/types.h>
  32 #include <unistd.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <fcntl.h>
  36
  37 #include "lib/global.h"
  38
  39 #include "lib/vfs/utilvfs.h"
  40
  41 #include "local.h"
  42
  43 /*** global variables ****************************************************************************/
  44
  45 /*** file scope macro definitions ****************************************************************/
  46
  47 /*** file scope type declarations ****************************************************************/
  48
  49 /*** file scope variables ************************************************************************/
  50
  51 static struct vfs_class vfs_local_ops;
  52
  53 /*** file scope functions ************************************************************************/
  54 /* --------------------------------------------------------------------------------------------- */
  55
  56 /**
  57  * Note: Some of this functions are not static. This has rather good
  58  * reason: exactly same functions would have to appear in sfs.c. This
  59  * saves both computer's memory and my work.  <pavel@ucw.cz>
  60  */
  61
  62
  63 /* --------------------------------------------------------------------------------------------- */
  64
  65 static void *
  66 local_open (const vfs_path_t * vpath, int flags, mode_t mode)
  67 {
  68     int *local_info;
  69     int fd;
  70     const vfs_path_element_t *path_element;
  71
  72     path_element = vfs_path_get_by_index (vpath, -1);
  73     fd = open (path_element->path, NO_LINEAR (flags), mode);
  74     if (fd == -1)
  75         return 0;
  76
  77     local_info = g_new (int, 1);
  78     *local_info = fd;
  79
  80     return local_info;
  81 }
  82
  83 /* --------------------------------------------------------------------------------------------- */
  84
  85 static void *
  86 local_opendir (const vfs_path_t * vpath)
  87 {
  88     DIR **local_info;
  89     DIR *dir;
  90     const vfs_path_element_t *path_element;
  91
  92     path_element = vfs_path_get_by_index (vpath, -1);
  93     dir = opendir (path_element->path);
  94     if (!dir)
  95         return 0;
  96
  97     local_info = (DIR **) g_new (DIR *, 1);
  98     *local_info = dir;
  99
 100     return local_info;
 101 }
 102
 103 /* --------------------------------------------------------------------------------------------- */
 104
 105 static void *
 106 local_readdir (void *data)
 107 {
 108     return readdir (*(DIR **) data);
 109 }
 110
 111 /* --------------------------------------------------------------------------------------------- */
 112
 113 static int
 114 local_closedir (void *data)
 115 {
 116     int i;
 117
 118     i = closedir (*(DIR **) data);
 119     g_free (data);
 120     return i;
 121 }
 122
 123 /* --------------------------------------------------------------------------------------------- */
 124
 125 static int
 126 local_stat (const vfs_path_t * vpath, struct stat *buf)
 127 {
 128     const vfs_path_element_t *path_element;
 129
 130     path_element = vfs_path_get_by_index (vpath, -1);
 131     return stat (path_element->path, buf);
 132 }
 133
 134 /* --------------------------------------------------------------------------------------------- */
 135
 136 static int
 137 local_lstat (const vfs_path_t * vpath, struct stat *buf)
 138 {
 139     const vfs_path_element_t *path_element;
 140
 141     path_element = vfs_path_get_by_index (vpath, -1);
 142 #ifndef HAVE_STATLSTAT
 143     return lstat (path_element->path, buf);
 144 #else
 145     return statlstat (path_element->path, buf);
 146 #endif
 147 }
 148
 149 /* --------------------------------------------------------------------------------------------- */
 150
 151 static int
 152 local_chmod (const vfs_path_t * vpath, mode_t mode)
 153 {
 154     const vfs_path_element_t *path_element;
 155
 156     path_element = vfs_path_get_by_index (vpath, -1);
 157     return chmod (path_element->path, mode);
 158 }
 159
 160 /* --------------------------------------------------------------------------------------------- */
 161
 162 static int
 163 local_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
 164 {
 165     const vfs_path_element_t *path_element;
 166
 167     path_element = vfs_path_get_by_index (vpath, -1);
 168     return chown (path_element->path, owner, group);
 169 }
 170
 171 /* --------------------------------------------------------------------------------------------- */
 172
 173 static int
 174 local_utime (const vfs_path_t * vpath, struct utimbuf *times)
 175 {
 176     const vfs_path_element_t *path_element;
 177
 178     path_element = vfs_path_get_by_index (vpath, -1);
 179     return utime (path_element->path, times);
 180 }
 181
 182 /* --------------------------------------------------------------------------------------------- */
 183
 184 static int
 185 local_readlink (const vfs_path_t * vpath, char *buf, size_t size)
 186 {
 187     const vfs_path_element_t *path_element;
 188
 189     path_element = vfs_path_get_by_index (vpath, -1);
 190     return readlink (path_element->path, buf, size);
 191 }
 192
 193 /* --------------------------------------------------------------------------------------------- */
 194
 195 static int
 196 local_unlink (const vfs_path_t * vpath)
 197 {
 198     const vfs_path_element_t *path_element;
 199
 200     path_element = vfs_path_get_by_index (vpath, -1);
 201     return unlink (path_element->path);
 202 }
 203
 204 /* --------------------------------------------------------------------------------------------- */
 205
 206 static int
 207 local_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
 208 {
 209     const vfs_path_element_t *path_element1;
 210     const vfs_path_element_t *path_element2;
 211
 212     path_element1 = vfs_path_get_by_index (vpath1, -1);
 213     path_element2 = vfs_path_get_by_index (vpath2, -1);
 214     return symlink (path_element1->path, path_element2->path);
 215 }
 216
 217 /* --------------------------------------------------------------------------------------------- */
 218
 219 static ssize_t
 220 local_write (void *data, const char *buf, size_t nbyte)
 221 {
 222     int fd;
 223     int n;
 224
 225     if (!data)
 226         return -1;
 227
 228     fd = *(int *) data;
 229     while ((n = write (fd, buf, nbyte)) == -1)
 230     {
 231 #ifdef EAGAIN
 232         if (errno == EAGAIN)
 233             continue;
 234 #endif
 235 #ifdef EINTR
 236         if (errno == EINTR)
 237             continue;
 238 #endif
 239         break;
 240     }
 241     return n;
 242 }
 243
 244 /* --------------------------------------------------------------------------------------------- */
 245
 246 static int
 247 local_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
 248 {
 249     const vfs_path_element_t *path_element1;
 250     const vfs_path_element_t *path_element2;
 251
 252     path_element1 = vfs_path_get_by_index (vpath1, -1);
 253     path_element2 = vfs_path_get_by_index (vpath2, -1);
 254     return rename (path_element1->path, path_element2->path);
 255 }
 256
 257 /* --------------------------------------------------------------------------------------------- */
 258
 259 static int
 260 local_chdir (const vfs_path_t * vpath)
 261 {
 262     const vfs_path_element_t *path_element;
 263
 264     path_element = vfs_path_get_by_index (vpath, -1);
 265     return chdir (path_element->path);
 266 }
 267
 268 /* --------------------------------------------------------------------------------------------- */
 269
 270 static int
 271 local_mknod (const vfs_path_t * vpath, mode_t mode, dev_t dev)
 272 {
 273     const vfs_path_element_t *path_element;
 274
 275     path_element = vfs_path_get_by_index (vpath, -1);
 276     return mknod (path_element->path, mode, dev);
 277 }
 278
 279 /* --------------------------------------------------------------------------------------------- */
 280
 281 static int
 282 local_link (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
 283 {
 284     const vfs_path_element_t *path_element1;
 285     const vfs_path_element_t *path_element2;
 286
 287     path_element1 = vfs_path_get_by_index (vpath1, -1);
 288     path_element2 = vfs_path_get_by_index (vpath2, -1);
 289     return link (path_element1->path, path_element2->path);
 290 }
 291
 292 /* --------------------------------------------------------------------------------------------- */
 293
 294 static int
 295 local_mkdir (const vfs_path_t * vpath, mode_t mode)
 296 {
 297     const vfs_path_element_t *path_element;
 298
 299     path_element = vfs_path_get_by_index (vpath, -1);
 300     return mkdir (path_element->path, mode);
 301 }
 302
 303 /* --------------------------------------------------------------------------------------------- */
 304
 305 static int
 306 local_rmdir (const vfs_path_t * vpath)
 307 {
 308     const vfs_path_element_t *path_element;
 309
 310     path_element = vfs_path_get_by_index (vpath, -1);
 311     return rmdir (path_element->path);
 312 }
 313
 314 /* --------------------------------------------------------------------------------------------- */
 315
 316 static vfs_path_t *
 317 local_getlocalcopy (const vfs_path_t * vpath)
 318 {
 319     return vfs_path_clone (vpath);
 320 }
 321
 322 /* --------------------------------------------------------------------------------------------- */
 323
 324 static int
 325 local_ungetlocalcopy (const vfs_path_t * vpath, const vfs_path_t * local, gboolean has_changed)
 326 {
 327     (void) vpath;
 328     (void) local;
 329     (void) has_changed;
 330
 331     return 0;
 332 }
 333
 334 /* --------------------------------------------------------------------------------------------- */
 335
 336 static int
 337 local_which (struct vfs_class *me, const char *path)
 338 {
 339     (void) me;
 340     (void) path;
 341
 342     return 0;                   /* Every path which other systems do not like is expected to be ours */
 343 }
 344
 345 /* --------------------------------------------------------------------------------------------- */
 346 /*** public functions ****************************************************************************/
 347 /* --------------------------------------------------------------------------------------------- */
 348
 349 ssize_t
 350 local_read (void *data, char *buffer, size_t count)
 351 {
 352     int n;
 353
 354     if (!data)
 355         return -1;
 356
 357     while ((n = read (*((int *) data), buffer, count)) == -1)
 358     {
 359 #ifdef EAGAIN
 360         if (errno == EAGAIN)
 361             continue;
 362 #endif
 363 #ifdef EINTR
 364         if (errno == EINTR)
 365             continue;
 366 #endif
 367         return -1;
 368     }
 369     return n;
 370 }
 371
 372 /* --------------------------------------------------------------------------------------------- */
 373
 374 int
 375 local_close (void *data)
 376 {
 377     int fd;
 378
 379     if (!data)
 380         return -1;
 381
 382     fd = *(int *) data;
 383     g_free (data);
 384     return close (fd);
 385 }
 386
 387 /* --------------------------------------------------------------------------------------------- */
 388
 389 int
 390 local_errno (struct vfs_class *me)
 391 {
 392     (void) me;
 393     return errno;
 394 }
 395
 396 /* --------------------------------------------------------------------------------------------- */
 397
 398 int
 399 local_fstat (void *data, struct stat *buf)
 400 {
 401     /* FIXME: avoid type cast */
 402     return fstat (*((int *) data), buf);
 403 }
 404
 405 /* --------------------------------------------------------------------------------------------- */
 406
 407 off_t
 408 local_lseek (void *data, off_t offset, int whence)
 409 {
 410     int fd = *(int *) data;
 411
 412     return lseek (fd, offset, whence);
 413 }
 414
 415 /* --------------------------------------------------------------------------------------------- */
 416
 417 void
 418 init_localfs (void)
 419 {
 420     vfs_local_ops.name = "localfs";
 421     vfs_local_ops.flags = VFSF_LOCAL;
 422     vfs_local_ops.which = local_which;
 423     vfs_local_ops.open = local_open;
 424     vfs_local_ops.close = local_close;
 425     vfs_local_ops.read = local_read;
 426     vfs_local_ops.write = local_write;
 427     vfs_local_ops.opendir = local_opendir;
 428     vfs_local_ops.readdir = local_readdir;
 429     vfs_local_ops.closedir = local_closedir;
 430     vfs_local_ops.stat = local_stat;
 431     vfs_local_ops.lstat = local_lstat;
 432     vfs_local_ops.fstat = local_fstat;
 433     vfs_local_ops.chmod = local_chmod;
 434     vfs_local_ops.chown = local_chown;
 435     vfs_local_ops.utime = local_utime;
 436     vfs_local_ops.readlink = local_readlink;
 437     vfs_local_ops.symlink = local_symlink;
 438     vfs_local_ops.link = local_link;
 439     vfs_local_ops.unlink = local_unlink;
 440     vfs_local_ops.rename = local_rename;
 441     vfs_local_ops.chdir = local_chdir;
 442     vfs_local_ops.ferrno = local_errno;
 443     vfs_local_ops.lseek = local_lseek;
 444     vfs_local_ops.mknod = local_mknod;
 445     vfs_local_ops.getlocalcopy = local_getlocalcopy;
 446     vfs_local_ops.ungetlocalcopy = local_ungetlocalcopy;
 447     vfs_local_ops.mkdir = local_mkdir;
 448     vfs_local_ops.rmdir = local_rmdir;
 449     vfs_register_class (&vfs_local_ops);
 450 }
 451
 452 /* --------------------------------------------------------------------------------------------- */