examples/VFS/skel.c

   1 /*
   2  * Skeleton VFS module.  Implements passthrough operation of all VFS
   3  * calls to disk functions.
   4  *
   5  * Copyright (C) Tim Potter, 1999-2000
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdio.h>
  25 #include <sys/stat.h>
  26 #ifdef HAVE_UTIME_H
  27 #include <utime.h>
  28 #endif
  29 #ifdef HAVE_DIRENT_H
  30 #include <dirent.h>
  31 #endif
  32 #ifdef HAVE_FCNTL_H
  33 #include <fcntl.h>
  34 #endif
  35 #include <errno.h>
  36 #include <string.h>
  37
  38 #include <includes.h>
  39 #include <vfs.h>
  40
  41 extern struct vfs_ops default_vfs_ops;   /* For passthrough operation */
  42 extern struct vfs_ops skel_ops;
  43
  44 static int skel_connect(struct connection_struct *conn, const char *service, const char *user)
  45 {
  46         return default_vfs_ops.connect(conn, service, user);
  47 }
  48
  49 static void skel_disconnect(struct connection_struct *conn)
  50 {
  51         default_vfs_ops.disconnect(conn);
  52 }
  53
  54 static SMB_BIG_UINT skel_disk_free(struct connection_struct *conn, const char *path,
  55         BOOL small_query, SMB_BIG_UINT *bsize,
  56         SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
  57 {
  58         return default_vfs_ops.disk_free(conn, path, small_query, bsize,
  59                                          dfree, dsize);
  60 }
  61
  62 static DIR *skel_opendir(struct connection_struct *conn, const char *fname)
  63 {
  64         return default_vfs_ops.opendir(conn, fname);
  65 }
  66
  67 static struct dirent *skel_readdir(struct connection_struct *conn, DIR *dirp)
  68 {
  69         return default_vfs_ops.readdir(conn, dirp);
  70 }
  71
  72 static int skel_mkdir(struct connection_struct *conn, const char *path, mode_t mode)
  73 {
  74         return default_vfs_ops.mkdir(conn, path, mode);
  75 }
  76
  77 static int skel_rmdir(struct connection_struct *conn, const char *path)
  78 {
  79         return default_vfs_ops.rmdir(conn, path);
  80 }
  81
  82 static int skel_closedir(struct connection_struct *conn, DIR *dir)
  83 {
  84         return default_vfs_ops.closedir(conn, dir);
  85 }
  86
  87 static int skel_open(struct connection_struct *conn, const char *fname, int flags, mode_t mode)
  88 {
  89         return default_vfs_ops.open(conn, fname, flags, mode);
  90 }
  91
  92 static int skel_close(struct files_struct *fsp, int fd)
  93 {
  94         return default_vfs_ops.close(fsp, fd);
  95 }
  96
  97 static ssize_t skel_read(struct files_struct *fsp, int fd, void *data, size_t n)
  98 {
  99         return default_vfs_ops.read(fsp, fd, data, n);
 100 }
 101
 102 static ssize_t skel_write(struct files_struct *fsp, int fd, const void *data, size_t n)
 103 {
 104         return default_vfs_ops.write(fsp, fd, data, n);
 105 }
 106
 107 static SMB_OFF_T skel_lseek(struct files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 108 {
 109         return default_vfs_ops.lseek(fsp, filedes, offset, whence);
 110 }
 111
 112 static int skel_rename(struct connection_struct *conn, const char *old, const char *new)
 113 {
 114         return default_vfs_ops.rename(conn, old, new);
 115 }
 116
 117 static int skel_fsync(struct files_struct *fsp, int fd)
 118 {
 119         return default_vfs_ops.fsync(fsp, fd);
 120 }
 121
 122 static int skel_stat(struct connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 123 {
 124         return default_vfs_ops.stat(conn, fname, sbuf);
 125 }
 126
 127 static int skel_fstat(struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 128 {
 129         return default_vfs_ops.fstat(fsp, fd, sbuf);
 130 }
 131
 132 static int skel_lstat(struct connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 133 {
 134         return default_vfs_ops.lstat(conn, path, sbuf);
 135 }
 136
 137 static int skel_unlink(struct connection_struct *conn, const char *path)
 138 {
 139         return default_vfs_ops.unlink(conn, path);
 140 }
 141
 142 static int skel_chmod(struct connection_struct *conn, const char *path, mode_t mode)
 143 {
 144         return default_vfs_ops.chmod(conn, path, mode);
 145 }
 146
 147 static int skel_fchmod(struct files_struct *fsp, int fd, mode_t mode)
 148 {
 149         return default_vfs_ops.fchmod(fsp, fd, mode);
 150 }
 151
 152 static int skel_chown(struct connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 153 {
 154         return default_vfs_ops.chown(conn, path, uid, gid);
 155 }
 156
 157 static int skel_fchown(struct files_struct *fsp, int fd, uid_t uid, gid_t gid)
 158 {
 159         return default_vfs_ops.fchown(fsp, fd, uid, gid);
 160 }
 161
 162 static int skel_chdir(struct connection_struct *conn, const char *path)
 163 {
 164         return default_vfs_ops.chdir(conn, path);
 165 }
 166
 167 static char *skel_getwd(struct connection_struct *conn, char *buf)
 168 {
 169         return default_vfs_ops.getwd(conn, buf);
 170 }
 171
 172 static int skel_utime(struct connection_struct *conn, const char *path, struct utimbuf *times)
 173 {
 174         return default_vfs_ops.utime(conn, path, times);
 175 }
 176
 177 static int skel_ftruncate(struct files_struct *fsp, int fd, SMB_OFF_T offset)
 178 {
 179         return default_vfs_ops.ftruncate(fsp, fd, offset);
 180 }
 181
 182 static BOOL skel_lock(struct files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 183 {
 184         return default_vfs_ops.lock(fsp, fd, op, offset, count, type);
 185 }
 186
 187 static BOOL skel_symlink(struct connection_struct *conn, const char *oldpath, const char *newpath)
 188 {
 189         return default_vfs_ops.symlink(conn, oldpath, newpath);
 190 }
 191
 192 static BOOL skel_readlink(struct connection_struct *conn, const char *path, char *buf, size_t bufsiz)
 193 {
 194         return default_vfs_ops.readlink(conn, path, buf, bufsiz);
 195 }
 196
 197 static int skel_link(struct connection_struct *conn, const char *oldpath, const char *newpath)
 198 {
 199         return default_vfs_ops.link(conn, oldpath, newpath);
 200 }
 201
 202 static int skel_mknod(struct connection_struct *conn, const char *path, mode_t mode, SMB_DEV_T dev)
 203 {
 204         return default_vfs_ops.mknod(conn, path, mode, dev);
 205 }
 206
 207 static char *skel_realpath(struct connection_struct *conn, const char *path, char *resolved_path)
 208 {
 209         return default_vfs_ops.realpath(conn, path, resolved_path);
 210 }
 211
 212 static size_t skel_fget_nt_acl(struct files_struct *fsp, int fd, struct security_descriptor_info **ppdesc)
 213 {
 214         return default_vfs_ops.fget_nt_acl(fsp, fd, ppdesc);
 215 }
 216
 217 static size_t skel_get_nt_acl(struct files_struct *fsp, const char *name, struct security_descriptor_info **ppdesc)
 218 {
 219         return default_vfs_ops.get_nt_acl(fsp, name, ppdesc);
 220 }
 221
 222 static BOOL skel_fset_nt_acl(struct files_struct *fsp, int fd, uint32 security_info_sent, struct security_descriptor_info *psd)
 223 {
 224         return default_vfs_ops.fset_nt_acl(fsp, fd, security_info_sent, psd);
 225 }
 226
 227 static BOOL skel_set_nt_acl(struct files_struct *fsp, const char *name, uint32 security_info_sent, struct security_descriptor_info *psd)
 228 {
 229         return default_vfs_ops.set_nt_acl(fsp, name, security_info_sent, psd);
 230 }
 231
 232 static BOOL skel_chmod_acl(struct connection_struct *conn, const char *name, mode_t mode)
 233 {
 234         return default_vfs_ops.chmod_acl(conn, name, mode);
 235 }
 236
 237 static BOOL skel_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
 238 {
 239         return default_vfs_ops.fchmod_acl(fsp, fd, mode);
 240 }
 241
 242 static int skel_sys_acl_get_entry(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 243 {
 244         return default_vfs_ops.sys_acl_get_entry(conn, theacl, entry_id, entry_p);
 245 }
 246
 247 static int skel_sys_acl_get_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
 248 {
 249         return default_vfs_ops.sys_acl_get_tag_type(conn, entry_d, tag_type_p);
 250 }
 251
 252 static int skel_sys_acl_get_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 253 {
 254         return default_vfs_ops.sys_acl_get_permset(conn, entry_d, permset_p);
 255 }
 256
 257 static void *skel_sys_acl_get_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
 258 {
 259         return default_vfs_ops.sys_acl_get_qualifier(conn, entry_d);
 260 }
 261
 262 static SMB_ACL_T skel_sys_acl_get_file(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
 263 {
 264         return default_vfs_ops.sys_acl_get_file(conn, path_p, type);
 265 }
 266
 267 static SMB_ACL_T skel_sys_acl_get_fd(struct files_struct *fsp, int fd)
 268 {
 269         return default_vfs_ops.sys_acl_get_fd(fsp, fd);
 270 }
 271
 272 static int skel_sys_acl_clear_perms(struct connection_struct *conn, SMB_ACL_PERMSET_T permset)
 273 {
 274         return default_vfs_ops.sys_acl_clear_perms(conn, permset);
 275 }
 276
 277 static int skel_sys_acl_add_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 278 {
 279         return default_vfs_ops.sys_acl_add_perm(conn, permset, perm);
 280 }
 281
 282 static char *skel_sys_acl_to_text(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
 283 {
 284         return default_vfs_ops.sys_acl_to_text(conn, theacl, plen);
 285 }
 286
 287 static SMB_ACL_T skel_sys_acl_init(struct connection_struct *conn, int count)
 288 {
 289         return default_vfs_ops.sys_acl_init(conn, count);
 290 }
 291
 292 static int skel_sys_acl_create_entry(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 293 {
 294         return default_vfs_ops.sys_acl_create_entry(conn, pacl, pentry);
 295 }
 296
 297 static int skel_sys_acl_set_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
 298 {
 299         return default_vfs_ops.sys_acl_set_tag_type(conn, entry, tagtype);
 300 }
 301
 302 static int skel_sys_acl_set_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
 303 {
 304         return default_vfs_ops.sys_acl_set_qualifier(conn, entry, qual);
 305 }
 306
 307 static int skel_sys_acl_set_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
 308 {
 309         return default_vfs_ops.sys_acl_set_permset(conn, entry, permset);
 310 }
 311
 312 static int skel_sys_acl_valid(struct connection_struct *conn, SMB_ACL_T theacl )
 313 {
 314         return default_vfs_ops.sys_acl_valid(conn, theacl );
 315 }
 316
 317 static int skel_sys_acl_set_file(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 318 {
 319         return default_vfs_ops.sys_acl_set_file(conn, name, acltype, theacl);
 320 }
 321
 322 static int skel_sys_acl_set_fd(struct files_struct *fsp, int fd, SMB_ACL_T theacl)
 323 {
 324         return default_vfs_ops.sys_acl_set_fd(fsp, fd, theacl);
 325 }
 326
 327 static int skel_sys_acl_delete_def_file(struct connection_struct *conn, const char *path)
 328 {
 329         return default_vfs_ops.sys_acl_delete_def_file(conn, path);
 330 }
 331
 332 static int skel_sys_acl_get_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 333 {
 334         return default_vfs_ops.sys_acl_get_perm(conn, permset, perm);
 335 }
 336
 337 static int skel_sys_acl_free_text(struct connection_struct *conn, char *text)
 338 {
 339         return default_vfs_ops.sys_acl_free_text(conn, text);
 340 }
 341
 342 static int skel_sys_acl_free_acl(struct connection_struct *conn, SMB_ACL_T posix_acl)
 343 {
 344         return default_vfs_ops.sys_acl_free_acl(conn, posix_acl);
 345 }
 346
 347 static int skel_sys_acl_free_qualifier(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
 348 {
 349         return default_vfs_ops.sys_acl_free_qualifier(conn, qualifier, tagtype);
 350 }
 351
 352 /* VFS initialisation - return vfs_ops function pointer structure */
 353
 354 struct vfs_ops *vfs_init(int *vfs_version, struct vfs_ops *def_vfs_ops)
 355 {
 356         struct vfs_ops tmp_ops;
 357
 358         DEBUG(3, ("Initialising default vfs hooks\n"));
 359
 360         *vfs_version = SMB_VFS_INTERFACE_VERSION;
 361         memcpy(&tmp_ops, def_vfs_ops, sizeof(struct vfs_ops));
 362
 363         tmp_ops.connect = skel_connect;
 364         tmp_ops.disconnect = skel_disconnect;
 365         tmp_ops.disk_free = skel_disk_free;
 366
 367         /* Directory operations */
 368
 369         tmp_ops.opendir = skel_opendir;
 370         tmp_ops.readdir = skel_readdir;
 371         tmp_ops.mkdir = skel_mkdir;
 372         tmp_ops.rmdir = skel_rmdir;
 373         tmp_ops.closedir = skel_closedir;
 374
 375         /* File operations */
 376
 377         tmp_ops.open = skel_open;
 378         tmp_ops.close = skel_close;
 379         tmp_ops.read = skel_read;
 380         tmp_ops.write = skel_write;
 381         tmp_ops.lseek = skel_lseek;
 382         tmp_ops.rename = skel_rename;
 383         tmp_ops.fsync = skel_fsync;
 384         tmp_ops.stat = skel_stat;
 385         tmp_ops.fstat = skel_fstat;
 386         tmp_ops.lstat = skel_lstat;
 387         tmp_ops.unlink = skel_unlink;
 388         tmp_ops.chmod = skel_chmod;
 389         tmp_ops.fchmod = skel_fchmod;
 390         tmp_ops.chown = skel_chown;
 391         tmp_ops.fchown = skel_fchown;
 392         tmp_ops.chdir = skel_chdir;
 393         tmp_ops.getwd = skel_getwd;
 394         tmp_ops.utime = skel_utime;
 395         tmp_ops.ftruncate = skel_ftruncate;
 396         tmp_ops.lock = skel_lock;
 397         tmp_ops.symlink = skel_symlink;
 398         tmp_ops.readlink = skel_readlink;
 399         tmp_ops.link = skel_link;
 400         tmp_ops.mknod = skel_mknod;
 401         tmp_ops.realpath = skel_realpath;
 402
 403         tmp_ops.fget_nt_acl = skel_fget_nt_acl;
 404         tmp_ops.get_nt_acl = skel_get_nt_acl;
 405         tmp_ops.fset_nt_acl = skel_fset_nt_acl;
 406         tmp_ops.set_nt_acl = skel_set_nt_acl;
 407
 408         /* POSIX ACL operations. */
 409
 410         tmp_ops.chmod_acl = skel_chmod_acl;
 411         tmp_ops.fchmod_acl = skel_fchmod_acl;
 412         tmp_ops.sys_acl_get_entry = skel_sys_acl_get_entry;
 413         tmp_ops.sys_acl_get_tag_type = skel_sys_acl_get_tag_type;
 414         tmp_ops.sys_acl_get_permset = skel_sys_acl_get_permset;
 415         tmp_ops.sys_acl_get_qualifier = skel_sys_acl_get_qualifier;
 416         tmp_ops.sys_acl_get_file = skel_sys_acl_get_file;
 417         tmp_ops.sys_acl_get_fd = skel_sys_acl_get_fd;
 418         tmp_ops.sys_acl_clear_perms = skel_sys_acl_clear_perms;
 419         tmp_ops.sys_acl_add_perm = skel_sys_acl_add_perm;
 420         tmp_ops.sys_acl_to_text = skel_sys_acl_to_text;
 421         tmp_ops.sys_acl_init = skel_sys_acl_init;
 422         tmp_ops.sys_acl_create_entry = skel_sys_acl_create_entry;
 423         tmp_ops.sys_acl_set_tag_type = skel_sys_acl_set_tag_type;
 424         tmp_ops.sys_acl_set_qualifier = skel_sys_acl_set_qualifier;
 425         tmp_ops.sys_acl_set_permset = skel_sys_acl_set_permset;
 426         tmp_ops.sys_acl_valid = skel_sys_acl_valid;
 427         tmp_ops.sys_acl_set_file = skel_sys_acl_set_file;
 428         tmp_ops.sys_acl_set_fd = skel_sys_acl_set_fd;
 429         tmp_ops.sys_acl_delete_def_file = skel_sys_acl_delete_def_file;
 430         tmp_ops.sys_acl_get_perm = skel_sys_acl_get_perm;
 431         tmp_ops.sys_acl_free_text = skel_sys_acl_free_text;
 432         tmp_ops.sys_acl_free_acl = skel_sys_acl_free_acl;
 433         tmp_ops.sys_acl_free_qualifier = skel_sys_acl_free_qualifier;
 434
 435         memcpy(&skel_ops, &tmp_ops, sizeof(struct vfs_ops));
 436
 437         return &skel_ops;
 438 }
 439
 440 /* VFS operations structure */
 441
 442 struct vfs_ops skel_ops = {
 443
 444         /* Disk operations */
 445
 446         skel_connect,
 447         skel_disconnect,
 448         skel_disk_free,
 449
 450         /* Directory operations */
 451
 452         skel_opendir,
 453         skel_readdir,
 454         skel_mkdir,
 455         skel_rmdir,
 456         skel_closedir,
 457
 458         /* File operations */
 459
 460         skel_open,
 461         skel_close,
 462         skel_read,
 463         skel_write,
 464         skel_lseek,
 465         skel_rename,
 466         skel_fsync,
 467         skel_stat,
 468         skel_fstat,
 469         skel_lstat,
 470         skel_unlink,
 471         skel_chmod,
 472         skel_fchmod,
 473         skel_chown,
 474         skel_fchown,
 475         skel_chdir,
 476         skel_getwd,
 477         skel_utime,
 478         skel_ftruncate,
 479         skel_lock,
 480         skel_symlink,
 481         skel_readlink,
 482         skel_link,
 483         skel_mknod,
 484         skel_realpath,
 485
 486         /* NT File ACL operations */
 487
 488         skel_fget_nt_acl,
 489         skel_get_nt_acl,
 490         skel_fset_nt_acl,
 491         skel_set_nt_acl,
 492
 493         /* POSIX ACL operations */
 494
 495         skel_chmod_acl,
 496         skel_fchmod_acl,
 497
 498         skel_sys_acl_get_entry,
 499         skel_sys_acl_get_tag_type,
 500         skel_sys_acl_get_permset,
 501         skel_sys_acl_get_qualifier,
 502         skel_sys_acl_get_file,
 503         skel_sys_acl_get_fd,
 504         skel_sys_acl_clear_perms,
 505         skel_sys_acl_add_perm,
 506         skel_sys_acl_to_text,
 507         skel_sys_acl_init,
 508         skel_sys_acl_create_entry,
 509         skel_sys_acl_set_tag_type,
 510         skel_sys_acl_set_qualifier,
 511         skel_sys_acl_set_permset,
 512         skel_sys_acl_valid,
 513         skel_sys_acl_set_file,
 514         skel_sys_acl_set_fd,
 515         skel_sys_acl_delete_def_file,
 516         skel_sys_acl_get_perm,
 517         skel_sys_acl_free_text,
 518         skel_sys_acl_free_acl,
 519         skel_sys_acl_free_qualifier
 520 };