source3/modules/vfs_posix_eadb.c

   1 /*
   2  * Store posix-level xattrs in a tdb (posix:eadb format)
   3  *
   4  * Copyright (C) Andrew Bartlett, 2011
   5  *
   6  * Based on vfs_xattr_tdb by
   7  * Copyright (C) Volker Lendecke, 2007
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "includes.h"
  24 #include "system/filesys.h"
  25 #include "smbd/smbd.h"
  26 #include "librpc/gen_ndr/xattr.h"
  27 #include "librpc/gen_ndr/ndr_xattr.h"
  28 #include "../librpc/gen_ndr/ndr_netlogon.h"
  29 #include <tdb.h>
  30 #include "lib/tdb_wrap/tdb_wrap.h"
  31 #include "ntvfs/posix/posix_eadb.h"
  32 #include "param/param.h"
  33 #include "lib/param/loadparm.h"
  34
  35 #undef DBGC_CLASS
  36 #define DBGC_CLASS DBGC_VFS
  37
  38 /*
  39  * Worker routine for getxattr and fgetxattr
  40  */
  41
  42 static ssize_t posix_eadb_getattr(struct tdb_wrap *db_ctx,
  43                                  const char *fname, int fd,
  44                                  const char *name, void *value, size_t size)
  45 {
  46         ssize_t result = -1;
  47         NTSTATUS status;
  48         DATA_BLOB blob;
  49
  50         DEBUG(10, ("posix_eadb_getattr called for file %s/fd %d, name %s\n",
  51                    fname, fd, name));
  52
  53         status = pull_xattr_blob_tdb_raw(db_ctx, talloc_tos(), name, fname, fd, size, &blob);
  54
  55         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
  56                 errno = ENOATTR;
  57                 return -1;
  58         }
  59
  60         if (!NT_STATUS_IS_OK(status)) {
  61                 DEBUG(10, ("posix_eadb_fetch_attrs failed: %s\n",
  62                            nt_errstr(status)));
  63                 errno = EINVAL;
  64                 return -1;
  65         }
  66
  67         if (blob.length > size) {
  68                 errno = ERANGE;
  69                 goto fail;
  70         }
  71
  72         memcpy(value, blob.data, blob.length);
  73         result = blob.length;
  74
  75  fail:
  76         return result;
  77 }
  78
  79 static ssize_t posix_eadb_getxattr(struct vfs_handle_struct *handle,
  80                                 const struct smb_filename *smb_fname,
  81                                 const char *name,
  82                                 void *value,
  83                                 size_t size)
  84 {
  85         struct tdb_wrap *db;
  86
  87         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
  88
  89         return posix_eadb_getattr(db, smb_fname->base_name,
  90                         -1, name, value, size);
  91 }
  92
  93 static ssize_t posix_eadb_fgetxattr(struct vfs_handle_struct *handle,
  94                                    struct files_struct *fsp,
  95                                    const char *name, void *value, size_t size)
  96 {
  97         struct tdb_wrap *db;
  98
  99         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 100
 101         return posix_eadb_getattr(db, fsp->fsp_name->base_name, fsp->fh->fd, name, value, size);
 102 }
 103
 104 /*
 105  * Worker routine for setxattr and fsetxattr
 106  */
 107
 108 static int posix_eadb_setattr(struct tdb_wrap *db_ctx,
 109                              const char *fname, int fd, const char *name,
 110                              const void *value, size_t size, int flags)
 111 {
 112         NTSTATUS status;
 113         DATA_BLOB data = data_blob_const(value, size);
 114
 115         DEBUG(10, ("posix_eadb_setattr called for file %s/fd %d, name %s\n",
 116                    fname, fd, name));
 117
 118         status = push_xattr_blob_tdb_raw(db_ctx, name, fname, fd, &data);
 119
 120         if (!NT_STATUS_IS_OK(status)) {
 121                 DEBUG(10, ("push_xattr_blob_tdb_raw failed: %s\n",
 122                            nt_errstr(status)));
 123                 return -1;
 124         }
 125
 126         return 0;
 127 }
 128
 129 static int posix_eadb_setxattr(struct vfs_handle_struct *handle,
 130                                 const struct smb_filename *smb_fname,
 131                                 const char *name,
 132                                 const void *value,
 133                                 size_t size,
 134                                 int flags)
 135 {
 136         struct tdb_wrap *db;
 137
 138         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 139
 140         return posix_eadb_setattr(db, smb_fname->base_name,
 141                         -1, name, value, size, flags);
 142 }
 143
 144 static int posix_eadb_fsetxattr(struct vfs_handle_struct *handle,
 145                                struct files_struct *fsp,
 146                                const char *name, const void *value,
 147                                size_t size, int flags)
 148 {
 149         struct tdb_wrap *db;
 150
 151         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 152
 153         return posix_eadb_setattr(db, fsp->fsp_name->base_name, fsp->fh->fd, name, value, size, flags);
 154 }
 155
 156 /*
 157  * Worker routine for listxattr and flistxattr
 158  */
 159
 160 static ssize_t posix_eadb_listattr(struct tdb_wrap *db_ctx,
 161                                   const char *fname, int fd, char *list,
 162                                   size_t size)
 163 {
 164         DATA_BLOB blob;
 165         NTSTATUS status;
 166
 167         status = list_posix_eadb_raw(db_ctx, talloc_tos(), fname, fd, &blob);
 168
 169         if (!NT_STATUS_IS_OK(status)) {
 170                 DEBUG(10, ("posix_eadb_fetch_attrs failed: %s\n",
 171                            nt_errstr(status)));
 172                 errno = EINVAL;
 173                 return -1;
 174         }
 175
 176         if (blob.length > size) {
 177                 errno = ERANGE;
 178                 TALLOC_FREE(blob.data);
 179                 return -1;
 180         }
 181
 182         memcpy(list, blob.data, blob.length);
 183
 184         TALLOC_FREE(blob.data);
 185         return blob.length;
 186 }
 187
 188 static ssize_t posix_eadb_listxattr(struct vfs_handle_struct *handle,
 189                                 const struct smb_filename *smb_fname,
 190                                 char *list,
 191                                 size_t size)
 192 {
 193         struct tdb_wrap *db;
 194
 195         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 196
 197         return posix_eadb_listattr(db, smb_fname->base_name, -1, list, size);
 198 }
 199
 200 static ssize_t posix_eadb_flistxattr(struct vfs_handle_struct *handle,
 201                                     struct files_struct *fsp, char *list,
 202                                     size_t size)
 203 {
 204         struct tdb_wrap *db;
 205
 206         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 207
 208         return posix_eadb_listattr(db, fsp->fsp_name->base_name, fsp->fh->fd, list, size);
 209 }
 210
 211 /*
 212  * Worker routine for removexattr and fremovexattr
 213  */
 214
 215 static int posix_eadb_removeattr(struct tdb_wrap *db_ctx,
 216                                 const char *fname, int fd, const char *name)
 217 {
 218         NTSTATUS status;
 219
 220         status = delete_posix_eadb_raw(db_ctx, name, fname, fd);
 221
 222         if (!NT_STATUS_IS_OK(status)) {
 223                 DEBUG(10, ("delete_posix_eadb_raw failed: %s\n",
 224                            nt_errstr(status)));
 225                 return -1;
 226         }
 227         return 0;
 228 }
 229
 230 static int posix_eadb_removexattr(struct vfs_handle_struct *handle,
 231                                 const struct smb_filename *smb_fname,
 232                                 const char *name)
 233 {
 234         struct tdb_wrap *db;
 235
 236         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 237
 238         return posix_eadb_removeattr(db, smb_fname->base_name, -1, name);
 239 }
 240
 241 static int posix_eadb_fremovexattr(struct vfs_handle_struct *handle,
 242                                   struct files_struct *fsp, const char *name)
 243 {
 244         struct tdb_wrap *db;
 245
 246         SMB_VFS_HANDLE_GET_DATA(handle, db, struct tdb_wrap, return -1);
 247
 248         return posix_eadb_removeattr(db, fsp->fsp_name->base_name, fsp->fh->fd, name);
 249 }
 250
 251 /*
 252  * Open the tdb file upon VFS_CONNECT
 253  */
 254
 255 static bool posix_eadb_init(int snum, struct tdb_wrap **p_db)
 256 {
 257         struct tdb_wrap *db;
 258         struct loadparm_context *lp_ctx;
 259         const char *eadb = lp_parm_const_string(snum, "posix", "eadb", NULL);
 260
 261         if (!eadb) {
 262                 DEBUG(0, ("Can not use vfs_posix_eadb without posix:eadb set\n"));
 263                 return false;
 264         }
 265
 266         lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
 267
 268         become_root();
 269         db = tdb_wrap_open(NULL, eadb, 50000,
 270                            lpcfg_tdb_flags(lp_ctx, TDB_DEFAULT),
 271                            O_RDWR|O_CREAT, 0600);
 272
 273         unbecome_root();
 274         talloc_unlink(NULL, lp_ctx);
 275         /* now we know dbname is not NULL */
 276
 277         if (db == NULL) {
 278 #if defined(ENOTSUP)
 279                 errno = ENOTSUP;
 280 #else
 281                 errno = ENOSYS;
 282 #endif
 283                 return false;
 284         }
 285
 286         *p_db = db;
 287         return true;
 288 }
 289
 290 /*
 291  * On unlink we need to delete the tdb record
 292  */
 293 static int posix_eadb_unlink(vfs_handle_struct *handle,
 294                             const struct smb_filename *smb_fname)
 295 {
 296         struct smb_filename *smb_fname_tmp = NULL;
 297         int ret = -1;
 298
 299         struct tdb_wrap *ea_tdb;
 300
 301         SMB_VFS_HANDLE_GET_DATA(handle, ea_tdb, struct tdb_wrap, return -1);
 302
 303         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
 304         if (smb_fname_tmp == NULL) {
 305                 errno = ENOMEM;
 306                 return -1;
 307         }
 308
 309         if (smb_fname->flags & SMB_FILENAME_POSIX_PATH) {
 310                 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_tmp);
 311         } else {
 312                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname_tmp);
 313         }
 314         if (ret == -1) {
 315                 goto out;
 316         }
 317
 318         if (smb_fname_tmp->st.st_ex_nlink == 1) {
 319                 NTSTATUS status;
 320
 321                 /* Only remove record on last link to file. */
 322
 323                 if (tdb_transaction_start(ea_tdb->tdb) != 0) {
 324                         ret = -1;
 325                         goto out;
 326                 }
 327
 328                 status = unlink_posix_eadb_raw(ea_tdb, smb_fname->base_name, -1);
 329                 if (!NT_STATUS_IS_OK(status)) {
 330                         tdb_transaction_cancel(ea_tdb->tdb);
 331                         ret = -1;
 332                         goto out;
 333                 }
 334         }
 335
 336         ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_tmp);
 337
 338         if (ret == -1) {
 339                 tdb_transaction_cancel(ea_tdb->tdb);
 340                 goto out;
 341         } else {
 342                 if (tdb_transaction_commit(ea_tdb->tdb) != 0) {
 343                         ret = -1;
 344                         goto out;
 345                 }
 346         }
 347
 348 out:
 349         TALLOC_FREE(smb_fname_tmp);
 350         return ret;
 351 }
 352
 353 /*
 354  * On rmdir we need to delete the tdb record
 355  */
 356 static int posix_eadb_rmdir(vfs_handle_struct *handle,
 357                         const struct smb_filename *smb_fname)
 358 {
 359         NTSTATUS status;
 360         struct tdb_wrap *ea_tdb;
 361         int ret;
 362         const char *path = smb_fname->base_name;
 363
 364         SMB_VFS_HANDLE_GET_DATA(handle, ea_tdb, struct tdb_wrap, return -1);
 365
 366         if (tdb_transaction_start(ea_tdb->tdb) != 0) {
 367                 return -1;
 368         }
 369
 370         status = unlink_posix_eadb_raw(ea_tdb, path, -1);
 371         if (!NT_STATUS_IS_OK(status)) {
 372                 tdb_transaction_cancel(ea_tdb->tdb);
 373         }
 374
 375         ret = SMB_VFS_NEXT_RMDIR(handle, smb_fname);
 376
 377         if (ret == -1) {
 378                 tdb_transaction_cancel(ea_tdb->tdb);
 379         } else {
 380                 if (tdb_transaction_commit(ea_tdb->tdb) != 0) {
 381                         return -1;
 382                 }
 383         }
 384
 385         return ret;
 386 }
 387
 388 /*
 389  * Destructor for the VFS private data
 390  */
 391
 392 static void close_xattr_db(void **data)
 393 {
 394         struct tdb_wrap **p_db = (struct tdb_wrap **)data;
 395         TALLOC_FREE(*p_db);
 396 }
 397
 398 static int posix_eadb_connect(vfs_handle_struct *handle, const char *service,
 399                           const char *user)
 400 {
 401         char *sname = NULL;
 402         int res, snum;
 403         struct tdb_wrap *db;
 404
 405         res = SMB_VFS_NEXT_CONNECT(handle, service, user);
 406         if (res < 0) {
 407                 return res;
 408         }
 409
 410         snum = find_service(talloc_tos(), service, &sname);
 411         if (snum == -1 || sname == NULL) {
 412                 /*
 413                  * Should not happen, but we should not fail just *here*.
 414                  */
 415                 return 0;
 416         }
 417
 418         if (!posix_eadb_init(snum, &db)) {
 419                 DEBUG(5, ("Could not init xattr tdb\n"));
 420                 lp_do_parameter(snum, "ea support", "False");
 421                 return 0;
 422         }
 423
 424         lp_do_parameter(snum, "ea support", "True");
 425
 426         SMB_VFS_HANDLE_SET_DATA(handle, db, close_xattr_db,
 427                                 struct tdb_wrap, return -1);
 428
 429         return 0;
 430 }
 431
 432 static struct vfs_fn_pointers vfs_posix_eadb_fns = {
 433         .getxattr_fn = posix_eadb_getxattr,
 434         .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
 435         .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
 436         .fgetxattr_fn = posix_eadb_fgetxattr,
 437         .setxattr_fn = posix_eadb_setxattr,
 438         .fsetxattr_fn = posix_eadb_fsetxattr,
 439         .listxattr_fn = posix_eadb_listxattr,
 440         .flistxattr_fn = posix_eadb_flistxattr,
 441         .removexattr_fn = posix_eadb_removexattr,
 442         .fremovexattr_fn = posix_eadb_fremovexattr,
 443         .unlink_fn = posix_eadb_unlink,
 444         .rmdir_fn = posix_eadb_rmdir,
 445         .connect_fn = posix_eadb_connect,
 446 };
 447
 448 static_decl_vfs;
 449 NTSTATUS vfs_posix_eadb_init(TALLOC_CTX *ctx)
 450 {
 451         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "posix_eadb",
 452                                 &vfs_posix_eadb_fns);
 453 }