examples/VFS/skel.c

   1 /*
   2  * Skeleton VFS module.
   3  *
   4  * Copyright (C) Tim Potter, 1999-2000
   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.2 2000/02/04 05:08:16 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, BOOL smallquery, 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_fsync(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 int skel_unlink(char *path);
  65 int skel_chmod(char *path, mode_t mode);
  66 int skel_utime(char *path, struct utimbuf *times);
  67
  68 /* VFS operations structure */
  69
  70 struct vfs_ops skel_ops = {
  71
  72     /* Disk operations */
  73
  74     skel_connect,
  75     skel_disconnect,
  76     skel_disk_free,
  77
  78     /* Directory operations */
  79
  80     skel_opendir,
  81     skel_readdir,
  82     skel_mkdir,
  83     skel_rmdir,
  84     skel_closedir,
  85
  86     /* File operations */
  87
  88     skel_open,
  89     skel_close,
  90     skel_read,
  91     skel_write,
  92     skel_lseek,
  93     skel_rename,
  94     skel_fsync,
  95     skel_stat,
  96     skel_fstat,
  97     skel_lstat,
  98     skel_unlink,
  99     skel_chmod,
 100     skel_utime
 101 };
 102
 103 /* VFS initialisation - return vfs_ops function pointer structure */
 104
 105 struct vfs_ops *vfs_init(void)
 106 {
 107     return(&skel_ops);
 108 }
 109
 110 /* Implementation of VFS functions.  Insert your useful stuff here */
 111
 112 extern struct vfs_ops default_vfs_ops;   /* For passthrough operation */
 113
 114 int skel_connect(struct vfs_connection_struct *conn, char *svc, char *user)
 115 {
 116     return default_vfs_ops.connect(conn, svc, user);
 117 }
 118
 119 void skel_disconnect(void)
 120 {
 121     default_vfs_ops.disconnect();
 122 }
 123
 124 SMB_BIG_UINT skel_disk_free(char *path, BOOL small_query, SMB_BIG_UINT *bsize,
 125                             SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 126 {
 127     return default_vfs_ops.disk_free(path, small_query, bsize, dfree, dsize);
 128 }
 129
 130 DIR *skel_opendir(char *fname)
 131 {
 132     return default_vfs_ops.opendir(fname);
 133 }
 134
 135 struct dirent *skel_readdir(DIR *dirp)
 136 {
 137     return default_vfs_ops.readdir(dirp);
 138 }
 139
 140 int skel_mkdir(char *path, mode_t mode)
 141 {
 142     return default_vfs_ops.mkdir(path, mode);
 143 }
 144
 145 int skel_rmdir(char *path)
 146 {
 147     return default_vfs_ops.rmdir(path);
 148 }
 149
 150 int skel_closedir(DIR *dir)
 151 {
 152     return default_vfs_ops.closedir(dir);
 153 }
 154
 155 int skel_open(char *fname, int flags, mode_t mode)
 156 {
 157     return default_vfs_ops.open(fname, flags, mode);
 158 }
 159
 160 int skel_close(int fd)
 161 {
 162     return default_vfs_ops.close(fd);
 163 }
 164
 165 ssize_t skel_read(int fd, char *data, size_t n)
 166 {
 167     return default_vfs_ops.read(fd, data, n);
 168 }
 169
 170 ssize_t skel_write(int fd, char *data, size_t n)
 171 {
 172     return default_vfs_ops.write(fd, data, n);
 173 }
 174
 175 SMB_OFF_T skel_lseek(int filedes, SMB_OFF_T offset, int whence)
 176 {
 177     return default_vfs_ops.lseek(filedes, offset, whence);
 178 }
 179
 180 int skel_rename(char *old, char *new)
 181 {
 182     return default_vfs_ops.rename(old, new);
 183 }
 184
 185 void skel_fsync(int fd)
 186 {
 187     default_vfs_ops.fsync(fd);
 188 }
 189
 190 int skel_stat(char *fname, SMB_STRUCT_STAT *sbuf)
 191 {
 192     return default_vfs_ops.stat(fname, sbuf);
 193 }
 194
 195 int skel_fstat(int fd, SMB_STRUCT_STAT *sbuf)
 196 {
 197     return default_vfs_ops.fstat(fd, sbuf);
 198 }
 199
 200 int skel_lstat(char *path, SMB_STRUCT_STAT *sbuf)
 201 {
 202     return default_vfs_ops.lstat(path, sbuf);
 203 }
 204
 205 int skel_unlink(char *path)
 206 {
 207     return default_vfs_ops.unlink(path);
 208 }
 209
 210 int skel_chmod(char *path, mode_t mode)
 211 {
 212     return default_vfs_ops.chmod(path, mode);
 213 }
 214
 215 int skel_utime(char *path, struct utimbuf *times)
 216 {
 217     return default_vfs_ops.utime(path, times);
 218 }