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 ssize_t skel_sendfile(int tofd, struct files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
 108                 SMB_OFF_T offset, size_t n)
 109 {
 110         return default_vfs_ops.sendfile(tofd, fsp, fromfd, hdr, offset, n);
 111 }
 112
 113 static SMB_OFF_T skel_lseek(struct files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 114 {
 115         return default_vfs_ops.lseek(fsp, filedes, offset, whence);
 116 }
 117
 118 static int skel_rename(struct connection_struct *conn, const char *old, const char *new)
 119 {
 120         return default_vfs_ops.rename(conn, old, new);
 121 }
 122
 123 static int skel_fsync(struct files_struct *fsp, int fd)
 124 {
 125         return default_vfs_ops.fsync(fsp, fd);
 126 }
 127
 128 static int skel_stat(struct connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 129 {
 130         return default_vfs_ops.stat(conn, fname, sbuf);
 131 }
 132
 133 static int skel_fstat(struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 134 {
 135         return default_vfs_ops.fstat(fsp, fd, sbuf);
 136 }
 137
 138 static int skel_lstat(struct connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 139 {
 140         return default_vfs_ops.lstat(conn, path, sbuf);
 141 }
 142
 143 static int skel_unlink(struct connection_struct *conn, const char *path)
 144 {
 145         return default_vfs_ops.unlink(conn, path);
 146 }
 147
 148 static int skel_chmod(struct connection_struct *conn, const char *path, mode_t mode)
 149 {
 150         return default_vfs_ops.chmod(conn, path, mode);
 151 }
 152
 153 static int skel_fchmod(struct files_struct *fsp, int fd, mode_t mode)
 154 {
 155         return default_vfs_ops.fchmod(fsp, fd, mode);
 156 }
 157
 158 static int skel_chown(struct connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 159 {
 160         return default_vfs_ops.chown(conn, path, uid, gid);
 161 }
 162
 163 static int skel_fchown(struct files_struct *fsp, int fd, uid_t uid, gid_t gid)
 164 {
 165         return default_vfs_ops.fchown(fsp, fd, uid, gid);
 166 }
 167
 168 static int skel_chdir(struct connection_struct *conn, const char *path)
 169 {
 170         return default_vfs_ops.chdir(conn, path);
 171 }
 172
 173 static char *skel_getwd(struct connection_struct *conn, char *buf)
 174 {
 175         return default_vfs_ops.getwd(conn, buf);
 176 }
 177
 178 static int skel_utime(struct connection_struct *conn, const char *path, struct utimbuf *times)
 179 {
 180         return default_vfs_ops.utime(conn, path, times);
 181 }
 182
 183 static int skel_ftruncate(struct files_struct *fsp, int fd, SMB_OFF_T offset)
 184 {
 185         return default_vfs_ops.ftruncate(fsp, fd, offset);
 186 }
 187
 188 static BOOL skel_lock(struct files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 189 {
 190         return default_vfs_ops.lock(fsp, fd, op, offset, count, type);
 191 }
 192
 193 static BOOL skel_symlink(struct connection_struct *conn, const char *oldpath, const char *newpath)
 194 {
 195         return default_vfs_ops.symlink(conn, oldpath, newpath);
 196 }
 197
 198 static BOOL skel_readlink(struct connection_struct *conn, const char *path, char *buf, size_t bufsiz)
 199 {
 200         return default_vfs_ops.readlink(conn, path, buf, bufsiz);
 201 }
 202
 203 static int skel_link(struct connection_struct *conn, const char *oldpath, const char *newpath)
 204 {
 205         return default_vfs_ops.link(conn, oldpath, newpath);
 206 }
 207
 208 static int skel_mknod(struct connection_struct *conn, const char *path, mode_t mode, SMB_DEV_T dev)
 209 {
 210         return default_vfs_ops.mknod(conn, path, mode, dev);
 211 }
 212
 213 static char *skel_realpath(struct connection_struct *conn, const char *path, char *resolved_path)
 214 {
 215         return default_vfs_ops.realpath(conn, path, resolved_path);
 216 }
 217
 218 static size_t skel_fget_nt_acl(struct files_struct *fsp, int fd, struct security_descriptor_info **ppdesc)
 219 {
 220         return default_vfs_ops.fget_nt_acl(fsp, fd, ppdesc);
 221 }
 222
 223 static size_t skel_get_nt_acl(struct files_struct *fsp, const char *name, struct security_descriptor_info **ppdesc)
 224 {
 225         return default_vfs_ops.get_nt_acl(fsp, name, ppdesc);
 226 }
 227
 228 static BOOL skel_fset_nt_acl(struct files_struct *fsp, int fd, uint32 security_info_sent, struct security_descriptor_info *psd)
 229 {
 230         return default_vfs_ops.fset_nt_acl(fsp, fd, security_info_sent, psd);
 231 }
 232
 233 static BOOL skel_set_nt_acl(struct files_struct *fsp, const char *name, uint32 security_info_sent, struct security_descriptor_info *psd)
 234 {
 235         return default_vfs_ops.set_nt_acl(fsp, name, security_info_sent, psd);
 236 }
 237
 238 static BOOL skel_chmod_acl(struct connection_struct *conn, const char *name, mode_t mode)
 239 {
 240         return default_vfs_ops.chmod_acl(conn, name, mode);
 241 }
 242
 243 static BOOL skel_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
 244 {
 245         return default_vfs_ops.fchmod_acl(fsp, fd, mode);
 246 }
 247
 248 static int skel_sys_acl_get_entry(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 249 {
 250         return default_vfs_ops.sys_acl_get_entry(conn, theacl, entry_id, entry_p);
 251 }
 252
 253 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)
 254 {
 255         return default_vfs_ops.sys_acl_get_tag_type(conn, entry_d, tag_type_p);
 256 }
 257
 258 static int skel_sys_acl_get_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 259 {
 260         return default_vfs_ops.sys_acl_get_permset(conn, entry_d, permset_p);
 261 }
 262
 263 static void *skel_sys_acl_get_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
 264 {
 265         return default_vfs_ops.sys_acl_get_qualifier(conn, entry_d);
 266 }
 267
 268 static SMB_ACL_T skel_sys_acl_get_file(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
 269 {
 270         return default_vfs_ops.sys_acl_get_file(conn, path_p, type);
 271 }
 272
 273 static SMB_ACL_T skel_sys_acl_get_fd(struct files_struct *fsp, int fd)
 274 {
 275         return default_vfs_ops.sys_acl_get_fd(fsp, fd);
 276 }
 277
 278 static int skel_sys_acl_clear_perms(struct connection_struct *conn, SMB_ACL_PERMSET_T permset)
 279 {
 280         return default_vfs_ops.sys_acl_clear_perms(conn, permset);
 281 }
 282
 283 static int skel_sys_acl_add_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 284 {
 285         return default_vfs_ops.sys_acl_add_perm(conn, permset, perm);
 286 }
 287
 288 static char *skel_sys_acl_to_text(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
 289 {
 290         return default_vfs_ops.sys_acl_to_text(conn, theacl, plen);
 291 }
 292
 293 static SMB_ACL_T skel_sys_acl_init(struct connection_struct *conn, int count)
 294 {
 295         return default_vfs_ops.sys_acl_init(conn, count);
 296 }
 297
 298 static int skel_sys_acl_create_entry(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 299 {
 300         return default_vfs_ops.sys_acl_create_entry(conn, pacl, pentry);
 301 }
 302
 303 static int skel_sys_acl_set_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
 304 {
 305         return default_vfs_ops.sys_acl_set_tag_type(conn, entry, tagtype);
 306 }
 307
 308 static int skel_sys_acl_set_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
 309 {
 310         return default_vfs_ops.sys_acl_set_qualifier(conn, entry, qual);
 311 }
 312
 313 static int skel_sys_acl_set_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
 314 {
 315         return default_vfs_ops.sys_acl_set_permset(conn, entry, permset);
 316 }
 317
 318 static int skel_sys_acl_valid(struct connection_struct *conn, SMB_ACL_T theacl )
 319 {
 320         return default_vfs_ops.sys_acl_valid(conn, theacl );
 321 }
 322
 323 static int skel_sys_acl_set_file(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 324 {
 325         return default_vfs_ops.sys_acl_set_file(conn, name, acltype, theacl);
 326 }
 327
 328 static int skel_sys_acl_set_fd(struct files_struct *fsp, int fd, SMB_ACL_T theacl)
 329 {
 330         return default_vfs_ops.sys_acl_set_fd(fsp, fd, theacl);
 331 }
 332
 333 static int skel_sys_acl_delete_def_file(struct connection_struct *conn, const char *path)
 334 {
 335         return default_vfs_ops.sys_acl_delete_def_file(conn, path);
 336 }
 337
 338 static int skel_sys_acl_get_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 339 {
 340         return default_vfs_ops.sys_acl_get_perm(conn, permset, perm);
 341 }
 342
 343 static int skel_sys_acl_free_text(struct connection_struct *conn, char *text)
 344 {
 345         return default_vfs_ops.sys_acl_free_text(conn, text);
 346 }
 347
 348 static int skel_sys_acl_free_acl(struct connection_struct *conn, SMB_ACL_T posix_acl)
 349 {
 350         return default_vfs_ops.sys_acl_free_acl(conn, posix_acl);
 351 }
 352
 353 static int skel_sys_acl_free_qualifier(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
 354 {
 355         return default_vfs_ops.sys_acl_free_qualifier(conn, qualifier, tagtype);
 356 }
 357
 358 /* VFS initialisation - return vfs_ops function pointer structure */
 359
 360 struct vfs_ops *vfs_init(int *vfs_version, struct vfs_ops *def_vfs_ops)
 361 {
 362         struct vfs_ops tmp_ops;
 363
 364         DEBUG(3, ("Initialising default vfs hooks\n"));
 365
 366         *vfs_version = SMB_VFS_INTERFACE_VERSION;
 367         memcpy(&tmp_ops, def_vfs_ops, sizeof(struct vfs_ops));
 368
 369         tmp_ops.connect = skel_connect;
 370         tmp_ops.disconnect = skel_disconnect;
 371         tmp_ops.disk_free = skel_disk_free;
 372
 373         /* Directory operations */
 374
 375         tmp_ops.opendir = skel_opendir;
 376         tmp_ops.readdir = skel_readdir;
 377         tmp_ops.mkdir = skel_mkdir;
 378         tmp_ops.rmdir = skel_rmdir;
 379         tmp_ops.closedir = skel_closedir;
 380
 381         /* File operations */
 382
 383         tmp_ops.open = skel_open;
 384         tmp_ops.close = skel_close;
 385         tmp_ops.read = skel_read;
 386         tmp_ops.write = skel_write;
 387         tmp_ops.lseek = skel_lseek;
 388         tmp_ops.sendfile = skel_sendfile;
 389         tmp_ops.rename = skel_rename;
 390         tmp_ops.fsync = skel_fsync;
 391         tmp_ops.stat = skel_stat;
 392         tmp_ops.fstat = skel_fstat;
 393         tmp_ops.lstat = skel_lstat;
 394         tmp_ops.unlink = skel_unlink;
 395         tmp_ops.chmod = skel_chmod;
 396         tmp_ops.fchmod = skel_fchmod;
 397         tmp_ops.chown = skel_chown;
 398         tmp_ops.fchown = skel_fchown;
 399         tmp_ops.chdir = skel_chdir;
 400         tmp_ops.getwd = skel_getwd;
 401         tmp_ops.utime = skel_utime;
 402         tmp_ops.ftruncate = skel_ftruncate;
 403         tmp_ops.lock = skel_lock;
 404         tmp_ops.symlink = skel_symlink;
 405         tmp_ops.readlink = skel_readlink;
 406         tmp_ops.link = skel_link;
 407         tmp_ops.mknod = skel_mknod;
 408         tmp_ops.realpath = skel_realpath;
 409
 410         tmp_ops.fget_nt_acl = skel_fget_nt_acl;
 411         tmp_ops.get_nt_acl = skel_get_nt_acl;
 412         tmp_ops.fset_nt_acl = skel_fset_nt_acl;
 413         tmp_ops.set_nt_acl = skel_set_nt_acl;
 414
 415         /* POSIX ACL operations. */
 416
 417         tmp_ops.chmod_acl = skel_chmod_acl;
 418         tmp_ops.fchmod_acl = skel_fchmod_acl;
 419         tmp_ops.sys_acl_get_entry = skel_sys_acl_get_entry;
 420         tmp_ops.sys_acl_get_tag_type = skel_sys_acl_get_tag_type;
 421         tmp_ops.sys_acl_get_permset = skel_sys_acl_get_permset;
 422         tmp_ops.sys_acl_get_qualifier = skel_sys_acl_get_qualifier;
 423         tmp_ops.sys_acl_get_file = skel_sys_acl_get_file;
 424         tmp_ops.sys_acl_get_fd = skel_sys_acl_get_fd;
 425         tmp_ops.sys_acl_clear_perms = skel_sys_acl_clear_perms;
 426         tmp_ops.sys_acl_add_perm = skel_sys_acl_add_perm;
 427         tmp_ops.sys_acl_to_text = skel_sys_acl_to_text;
 428         tmp_ops.sys_acl_init = skel_sys_acl_init;
 429         tmp_ops.sys_acl_create_entry = skel_sys_acl_create_entry;
 430         tmp_ops.sys_acl_set_tag_type = skel_sys_acl_set_tag_type;
 431         tmp_ops.sys_acl_set_qualifier = skel_sys_acl_set_qualifier;
 432         tmp_ops.sys_acl_set_permset = skel_sys_acl_set_permset;
 433         tmp_ops.sys_acl_valid = skel_sys_acl_valid;
 434         tmp_ops.sys_acl_set_file = skel_sys_acl_set_file;
 435         tmp_ops.sys_acl_set_fd = skel_sys_acl_set_fd;
 436         tmp_ops.sys_acl_delete_def_file = skel_sys_acl_delete_def_file;
 437         tmp_ops.sys_acl_get_perm = skel_sys_acl_get_perm;
 438         tmp_ops.sys_acl_free_text = skel_sys_acl_free_text;
 439         tmp_ops.sys_acl_free_acl = skel_sys_acl_free_acl;
 440         tmp_ops.sys_acl_free_qualifier = skel_sys_acl_free_qualifier;
 441
 442         memcpy(&skel_ops, &tmp_ops, sizeof(struct vfs_ops));
 443
 444         return &skel_ops;
 445 }
 446
 447 /* VFS operations structure */
 448
 449 struct vfs_ops skel_ops = {
 450
 451         /* Disk operations */
 452
 453         skel_connect,
 454         skel_disconnect,
 455         skel_disk_free,
 456
 457         /* Directory operations */
 458
 459         skel_opendir,
 460         skel_readdir,
 461         skel_mkdir,
 462         skel_rmdir,
 463         skel_closedir,
 464
 465         /* File operations */
 466
 467         skel_open,
 468         skel_close,
 469         skel_read,
 470         skel_write,
 471         skel_lseek,
 472         skel_sendfile,
 473         skel_rename,
 474         skel_fsync,
 475         skel_stat,
 476         skel_fstat,
 477         skel_lstat,
 478         skel_unlink,
 479         skel_chmod,
 480         skel_fchmod,
 481         skel_chown,
 482         skel_fchown,
 483         skel_chdir,
 484         skel_getwd,
 485         skel_utime,
 486         skel_ftruncate,
 487         skel_lock,
 488         skel_symlink,
 489         skel_readlink,
 490         skel_link,
 491         skel_mknod,
 492         skel_realpath,
 493
 494         /* NT File ACL operations */
 495
 496         skel_fget_nt_acl,
 497         skel_get_nt_acl,
 498         skel_fset_nt_acl,
 499         skel_set_nt_acl,
 500
 501         /* POSIX ACL operations */
 502
 503         skel_chmod_acl,
 504         skel_fchmod_acl,
 505
 506         skel_sys_acl_get_entry,
 507         skel_sys_acl_get_tag_type,
 508         skel_sys_acl_get_permset,
 509         skel_sys_acl_get_qualifier,
 510         skel_sys_acl_get_file,
 511         skel_sys_acl_get_fd,
 512         skel_sys_acl_clear_perms,
 513         skel_sys_acl_add_perm,
 514         skel_sys_acl_to_text,
 515         skel_sys_acl_init,
 516         skel_sys_acl_create_entry,
 517         skel_sys_acl_set_tag_type,
 518         skel_sys_acl_set_qualifier,
 519         skel_sys_acl_set_permset,
 520         skel_sys_acl_valid,
 521         skel_sys_acl_set_file,
 522         skel_sys_acl_set_fd,
 523         skel_sys_acl_delete_def_file,
 524         skel_sys_acl_get_perm,
 525         skel_sys_acl_free_text,
 526         skel_sys_acl_free_acl,
 527         skel_sys_acl_free_qualifier
 528 };