vfs/local.c

   1 #include <config.h>
   2 #include <errno.h>
   3 #include <sys/types.h>
   4 #include <unistd.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7
   8 #include <mhl/string.h>
   9
  10 #include "../src/global.h"
  11 #include "../src/tty.h"         /* enable/disable interrupt key */
  12 #include "../src/wtools.h"      /* message() */
  13 #include "../src/main.h"        /* print_vfs_message */
  14 #include "utilvfs.h"
  15 #include "vfs.h"
  16 #include "local.h"
  17
  18 /* Note: Some of this functions are not static. This has rather good
  19  * reason: exactly same functions would have to appear in sfs.c. This
  20  * saves both computer's memory and my work.  <pavel@ucw.cz>
  21  * */
  22
  23 static struct vfs_class vfs_local_ops;
  24
  25 static void *
  26 local_open (struct vfs_class *me, const char *file, int flags, int mode)
  27 {
  28     int *local_info;
  29     int fd;
  30
  31     (void) me;
  32
  33     fd = open (file, NO_LINEAR (flags), mode);
  34     if (fd == -1)
  35         return 0;
  36
  37     local_info = g_new (int, 1);
  38     *local_info = fd;
  39
  40     return local_info;
  41 }
  42
  43 ssize_t
  44 local_read (void *data, char *buffer, int count)
  45 {
  46     int n;
  47
  48     if (!data)
  49         return -1;
  50
  51     while ((n = read (*((int *) data), buffer, count)) == -1){
  52 #ifdef EAGAIN
  53         if (errno == EAGAIN) continue;
  54 #endif
  55 #ifdef EINTR
  56         if (errno == EINTR) continue;
  57 #endif
  58         return -1;
  59     }
  60     return n;
  61 }
  62
  63 int
  64 local_close (void *data)
  65 {
  66     int fd;
  67
  68     if (!data)
  69         return -1;
  70
  71     fd =  *(int *) data;
  72     g_free (data);
  73     return close (fd);
  74 }
  75
  76 int
  77 local_errno (struct vfs_class *me)
  78 {
  79     (void) me;
  80     return errno;
  81 }
  82
  83 static void *
  84 local_opendir (struct vfs_class *me, const char *dirname)
  85 {
  86     DIR **local_info;
  87     DIR *dir;
  88
  89     (void) me;
  90
  91     dir = opendir (dirname);
  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 static void *
 102 local_readdir (void *data)
 103 {
 104     return readdir (*(DIR **) data);
 105 }
 106
 107 static int
 108 local_closedir (void *data)
 109 {
 110     int i;
 111
 112     i = closedir (* (DIR **) data);
 113     g_free (data);
 114     return i;
 115 }
 116
 117 static int
 118 local_stat (struct vfs_class *me, const char *path, struct stat *buf)
 119 {
 120     (void) me;
 121
 122     return stat (path, buf);
 123 }
 124
 125 static int
 126 local_lstat (struct vfs_class *me, const char *path, struct stat *buf)
 127 {
 128     (void) me;
 129
 130 #ifndef HAVE_STATLSTAT
 131     return lstat (path,buf);
 132 #else
 133     return statlstat (path, buf);
 134 #endif
 135 }
 136
 137 int
 138 local_fstat (void *data, struct stat *buf)
 139 {
 140     /* FIXME: avoid type cast */
 141     return fstat (*((int *) data), buf);
 142 }
 143
 144 static int
 145 local_chmod (struct vfs_class *me, const char *path, int mode)
 146 {
 147     (void) me;
 148
 149     return chmod (path, mode);
 150 }
 151
 152 static int
 153 local_chown (struct vfs_class *me, const char *path, int owner, int group)
 154 {
 155     (void) me;
 156
 157     return chown (path, owner, group);
 158 }
 159
 160 static int
 161 local_utime (struct vfs_class *me, const char *path, struct utimbuf *times)
 162 {
 163     (void) me;
 164
 165     return utime (path, times);
 166 }
 167
 168 static int
 169 local_readlink (struct vfs_class *me, const char *path, char *buf, size_t size)
 170 {
 171     (void) me;
 172
 173     return readlink (path, buf, size);
 174 }
 175
 176 static int
 177 local_unlink (struct vfs_class *me, const char *path)
 178 {
 179     (void) me;
 180
 181     return unlink (path);
 182 }
 183
 184 static int
 185 local_symlink (struct vfs_class *me, const char *n1, const char *n2)
 186 {
 187     (void) me;
 188
 189     return symlink (n1, n2);
 190 }
 191
 192 static ssize_t
 193 local_write (void *data, const char *buf, int nbyte)
 194 {
 195     int fd;
 196     int n;
 197
 198     if (!data)
 199         return -1;
 200
 201     fd = * (int *) data;
 202     while ((n = write (fd, buf, nbyte)) == -1){
 203 #ifdef EAGAIN
 204         if (errno == EAGAIN) continue;
 205 #endif
 206 #ifdef EINTR
 207         if (errno == EINTR) continue;
 208 #endif
 209         break;
 210     }
 211     return n;
 212 }
 213
 214 static int
 215 local_rename (struct vfs_class *me, const char *a, const char *b)
 216 {
 217     (void) me;
 218
 219     return rename (a, b);
 220 }
 221
 222 static int
 223 local_chdir (struct vfs_class *me, const char *path)
 224 {
 225     (void) me;
 226
 227     return chdir (path);
 228 }
 229
 230 off_t
 231 local_lseek (void *data, off_t offset, int whence)
 232 {
 233     int fd = * (int *) data;
 234
 235     return lseek (fd, offset, whence);
 236 }
 237
 238 static int
 239 local_mknod (struct vfs_class *me, const char *path, int mode, int dev)
 240 {
 241     (void) me;
 242
 243     return mknod (path, mode, dev);
 244 }
 245
 246 static int
 247 local_link (struct vfs_class *me, const char *p1, const char *p2)
 248 {
 249     (void) me;
 250
 251     return link (p1, p2);
 252 }
 253
 254 static int
 255 local_mkdir (struct vfs_class *me, const char *path, mode_t mode)
 256 {
 257     (void) me;
 258
 259     return mkdir (path, mode);
 260 }
 261
 262 static int
 263 local_rmdir (struct vfs_class *me, const char *path)
 264 {
 265     (void) me;
 266
 267     return rmdir (path);
 268 }
 269
 270 static char *
 271 local_getlocalcopy (struct vfs_class *me, const char *path)
 272 {
 273     (void) me;
 274
 275     return mhl_str_dup (path);
 276 }
 277
 278 static int
 279 local_ungetlocalcopy (struct vfs_class *me, const char *path,
 280                       const char *local, int has_changed)
 281 {
 282     (void) me;
 283     (void) path;
 284     (void) local;
 285     (void) has_changed;
 286
 287     return 0;
 288 }
 289
 290 static int
 291 local_which (struct vfs_class *me, const char *path)
 292 {
 293     (void) me;
 294     (void) path;
 295
 296     return 0;           /* Every path which other systems do not like is expected to be ours */
 297 }
 298
 299 void
 300 init_localfs (void)
 301 {
 302     vfs_local_ops.name = "localfs";
 303     vfs_local_ops.flags = VFSF_LOCAL;
 304     vfs_local_ops.which = local_which;
 305     vfs_local_ops.open = local_open;
 306     vfs_local_ops.close = local_close;
 307     vfs_local_ops.read = local_read;
 308     vfs_local_ops.write = local_write;
 309     vfs_local_ops.opendir = local_opendir;
 310     vfs_local_ops.readdir = local_readdir;
 311     vfs_local_ops.closedir = local_closedir;
 312     vfs_local_ops.stat = local_stat;
 313     vfs_local_ops.lstat = local_lstat;
 314     vfs_local_ops.fstat = local_fstat;
 315     vfs_local_ops.chmod = local_chmod;
 316     vfs_local_ops.chown = local_chown;
 317     vfs_local_ops.utime = local_utime;
 318     vfs_local_ops.readlink = local_readlink;
 319     vfs_local_ops.symlink = local_symlink;
 320     vfs_local_ops.link = local_link;
 321     vfs_local_ops.unlink = local_unlink;
 322     vfs_local_ops.rename = local_rename;
 323     vfs_local_ops.chdir = local_chdir;
 324     vfs_local_ops.ferrno = local_errno;
 325     vfs_local_ops.lseek = local_lseek;
 326     vfs_local_ops.mknod = local_mknod;
 327     vfs_local_ops.getlocalcopy = local_getlocalcopy;
 328     vfs_local_ops.ungetlocalcopy = local_ungetlocalcopy;
 329     vfs_local_ops.mkdir = local_mkdir;
 330     vfs_local_ops.rmdir = local_rmdir;
 331     vfs_register_class (&vfs_local_ops);
 332 }