examples/VFS/skel.c

   1 /*
   2  * Skeleton VFS module.
   3  *
   4  * Copyright (C) Tim Potter, 1999
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program 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
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  * $Id: skel.c,v 1.1 2000/02/03 04:40:56 tpot Exp $
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <sys/stat.h>
  27 #ifdef HAVE_UTIME_H
  28 #include <utime.h>
  29 #endif
  30 #ifdef HAVE_DIRENT_H
  31 #include <dirent.h>
  32 #endif
  33 #ifdef HAVE_FCNTL_H
  34 #include <fcntl.h>
  35 #endif
  36 #include <errno.h>
  37 #include <string.h>
  38
  39 #include <vfs.h>
  40
  41 /* Function prototypes */
  42
  43 int skel_connect(struct vfs_connection_struct *conn, char *svc, char *user);
  44 void skel_disconnect(void);
  45 SMB_BIG_UINT skel_disk_free(char *path, SMB_BIG_UINT *bsize,
  46                             SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
  47
  48 DIR *skel_opendir(char *fname);
  49 struct dirent *skel_readdir(DIR *dirp);
  50 int skel_mkdir(char *path, mode_t mode);
  51 int skel_rmdir(char *path);
  52 int skel_closedir(DIR *dir);
  53
  54 int skel_open(char *fname, int flags, mode_t mode);
  55 int skel_close(int fd);
  56 ssize_t skel_read(int fd, char *data, size_t n);
  57 ssize_t skel_write(int fd, char *data, size_t n);
  58 SMB_OFF_T skel_lseek(int filedes, SMB_OFF_T offset, int whence);
  59 int skel_rename(char *old, char *new);
  60 void skel_sync(int fd);
  61 int skel_stat(char *fname, SMB_STRUCT_STAT *sbuf);
  62 int skel_fstat(int fd, SMB_STRUCT_STAT *sbuf);
  63 int skel_lstat(char *path, SMB_STRUCT_STAT *sbuf);
  64 BOOL skel_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
  65 int skel_unlink(char *path);
  66 int skel_chmod(char *path, mode_t mode);
  67 int skel_utime(char *path, struct utimbuf *times);
  68
  69 /* VFS operations structure */
  70
  71 struct vfs_ops skel_ops = {
  72
  73     /* Disk operations */
  74
  75     skel_connect,
  76     skel_disconnect,
  77     skel_disk_free,
  78
  79     /* Directory operations */
  80
  81     skel_opendir,
  82     skel_readdir,
  83     skel_mkdir,
  84     skel_rmdir,
  85     skel_closedir,
  86
  87     /* File operations */
  88
  89     skel_open,
  90     skel_close,
  91     skel_read,
  92     skel_write,
  93     skel_lseek,
  94     skel_rename,
  95     skel_sync,
  96     skel_stat,
  97     skel_fstat,
  98     skel_lstat,
  99     skel_lock,
 100     skel_unlink,
 101     skel_chmod,
 102     skel_utime
 103 };
 104
 105 /* VFS initialisation - return vfs_ops function pointer structure */
 106
 107 struct vfs_ops *vfs_init(void)
 108 {
 109     return(&skel_ops);
 110 }
 111
 112 /* Implementation of VFS functions.  Insert your useful stuff here */
 113
 114 extern struct vfs_ops default_vfs_ops;   /* For passthrough operation */
 115
 116 int skel_connect(struct vfs_connection_struct *conn, char *svc, char *user)
 117 {
 118     return default_vfs_ops.connect(conn, svc, user);
 119 }
 120
 121 void skel_disconnect(void)
 122 {
 123     default_vfs_ops.disconnect();
 124 }
 125
 126 SMB_BIG_UINT skel_disk_free(char *path, SMB_BIG_UINT *bsize,
 127                             SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 128 {
 129     return default_vfs_ops.disk_free(path, bsize, dfree, dsize);
 130 }
 131
 132 DIR *skel_opendir(char *fname)
 133 {
 134     return default_vfs_ops.opendir(fname);
 135 }
 136
 137 struct dirent *skel_readdir(DIR *dirp)
 138 {
 139     return default_vfs_ops.readdir(dirp);
 140 }
 141
 142 int skel_mkdir(char *path, mode_t mode)
 143 {
 144     return default_vfs_ops.mkdir(path, mode);
 145 }
 146
 147 int skel_rmdir(char *path)
 148 {
 149     return default_vfs_ops.rmdir(path);
 150 }
 151
 152 int skel_closedir(DIR *dir)
 153 {
 154     return default_vfs_ops.closedir(dir);
 155 }
 156
 157 int skel_open(char *fname, int flags, mode_t mode)
 158 {
 159     return default_vfs_ops.open(fname, flags, mode);
 160 }
 161
 162 int skel_close(int fd)
 163 {
 164     return default_vfs_ops.close(fd);
 165 }
 166
 167 ssize_t skel_read(int fd, char *data, size_t n)
 168 {
 169     return default_vfs_ops.read(fd, data, n);
 170 }
 171
 172 ssize_t skel_write(int fd, char *data, size_t n)
 173 {
 174     return default_vfs_ops.write(fd, data, n);
 175 }
 176
 177 SMB_OFF_T skel_lseek(int filedes, SMB_OFF_T offset, int whence)
 178 {
 179     return default_vfs_ops.lseek(filedes, offset, whence);
 180 }
 181
 182 int skel_rename(char *old, char *new)
 183 {
 184     return default_vfs_ops.rename(old, new);
 185 }
 186
 187 void skel_sync(int fd)
 188 {
 189     default_vfs_ops.sync(fd);
 190 }
 191
 192 int skel_stat(char *fname, SMB_STRUCT_STAT *sbuf)
 193 {
 194     return default_vfs_ops.stat(fname, sbuf);
 195 }
 196
 197 int skel_fstat(int fd, SMB_STRUCT_STAT *sbuf)
 198 {
 199     return default_vfs_ops.fstat(fd, sbuf);
 200 }
 201
 202 int skel_lstat(char *path, SMB_STRUCT_STAT *sbuf)
 203 {
 204     return default_vfs_ops.lstat(path, sbuf);
 205 }
 206
 207 BOOL skel_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 208 {
 209     return default_vfs_ops.lock(fd, op, offset, count, type);
 210 }
 211
 212 int skel_unlink(char *path)
 213 {
 214     return default_vfs_ops.unlink(path);
 215 }
 216
 217 int skel_chmod(char *path, mode_t mode)
 218 {
 219     return default_vfs_ops.chmod(path, mode);
 220 }
 221
 222 int skel_utime(char *path, struct utimbuf *times)
 223 {
 224     return default_vfs_ops.utime(path, times);
 225 }