src/vfs/local/local.c

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