source3/modules/vfs_fake_acls.c

   1 /*
   2  * Fake ACLs VFS module.  Implements passthrough operation of all VFS
   3  * calls to disk functions, except for file ownership and ACLs, which
   4  * are stored in xattrs.
   5  *
   6  * Copyright (C) Tim Potter, 1999-2000
   7  * Copyright (C) Alexander Bokovoy, 2002
   8  * Copyright (C) Andrew Bartlett, 2002,2012
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include "includes.h"
  25 #include "smbd/smbd.h"
  26 #include "system/filesys.h"
  27 #include "auth.h"
  28 #include "librpc/gen_ndr/ndr_smb_acl.h"
  29
  30 #undef DBGC_CLASS
  31 #define DBGC_CLASS DBGC_VFS
  32
  33 #define FAKE_UID "system.fake_uid"
  34 #define FAKE_GID "system.fake_gid"
  35 #define FAKE_ACL_ACCESS_XATTR "system.fake_access_acl"
  36 #define FAKE_ACL_DEFAULT_XATTR "system.fake_default_acl"
  37
  38 static int fake_acls_uid(vfs_handle_struct *handle,
  39                          struct smb_filename *smb_fname,
  40                          uid_t *uid)
  41 {
  42         ssize_t size;
  43         uint8_t uid_buf[4];
  44         size = SMB_VFS_NEXT_GETXATTR(handle, smb_fname,
  45                         FAKE_UID, uid_buf, sizeof(uid_buf));
  46         if (size == -1 && errno == ENOATTR) {
  47                 return 0;
  48         }
  49         if (size != 4) {
  50                 return -1;
  51         }
  52         *uid = IVAL(uid_buf, 0);
  53         return 0;
  54 }
  55
  56 static int fake_acls_gid(vfs_handle_struct *handle,
  57                          struct smb_filename *smb_fname,
  58                          uid_t *gid)
  59 {
  60         ssize_t size;
  61         uint8_t gid_buf[4];
  62
  63         size = SMB_VFS_NEXT_GETXATTR(handle, smb_fname,
  64                         FAKE_GID, gid_buf, sizeof(gid_buf));
  65         if (size == -1 && errno == ENOATTR) {
  66                 return 0;
  67         }
  68         if (size != 4) {
  69                 return -1;
  70         }
  71         *gid = IVAL(gid_buf, 0);
  72         return 0;
  73 }
  74
  75 static int fake_acls_fuid(vfs_handle_struct *handle,
  76                            files_struct *fsp,
  77                            uid_t *uid)
  78 {
  79         ssize_t size;
  80         uint8_t uid_buf[4];
  81
  82         size = SMB_VFS_NEXT_FGETXATTR(handle, fsp, FAKE_UID, uid_buf, sizeof(uid_buf));
  83         if (size == -1 && errno == ENOATTR) {
  84                 return 0;
  85         }
  86         if (size != 4) {
  87                 return -1;
  88         }
  89         *uid = IVAL(uid_buf, 0);
  90         return 0;
  91 }
  92
  93 static int fake_acls_fgid(vfs_handle_struct *handle,
  94                            files_struct *fsp,
  95                           uid_t *gid)
  96 {
  97         ssize_t size;
  98         uint8_t gid_buf[4];
  99
 100         size = SMB_VFS_NEXT_FGETXATTR(handle, fsp, FAKE_GID, gid_buf, sizeof(gid_buf));
 101         if (size == -1 && errno == ENOATTR) {
 102                 return 0;
 103         }
 104         if (size != 4) {
 105                 return -1;
 106         }
 107         *gid = IVAL(gid_buf, 0);
 108         return 0;
 109 }
 110
 111 static int fake_acls_stat(vfs_handle_struct *handle,
 112                            struct smb_filename *smb_fname)
 113 {
 114         int ret = -1;
 115
 116         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
 117         if (ret == 0) {
 118                 TALLOC_CTX *frame = talloc_stackframe();
 119                 char *path;
 120                 struct smb_filename smb_fname_base = {
 121                         .base_name = smb_fname->base_name
 122                 };
 123                 NTSTATUS status;
 124                 /*
 125                  * As we're calling getxattr directly here
 126                  * we need to use only the base_name, not
 127                  * the full name containing any stream name.
 128                  */
 129                 status = get_full_smb_filename(frame, &smb_fname_base, &path);
 130                 if (!NT_STATUS_IS_OK(status)) {
 131                         errno = map_errno_from_nt_status(status);
 132                         TALLOC_FREE(frame);
 133                         return -1;
 134                 }
 135
 136                 ret = fake_acls_uid(handle, &smb_fname_base,
 137                                         &smb_fname->st.st_ex_uid);
 138                 if (ret != 0) {
 139                         TALLOC_FREE(frame);
 140                         return ret;
 141                 }
 142                 ret = fake_acls_gid(handle, &smb_fname_base,
 143                                         &smb_fname->st.st_ex_gid);
 144                 if (ret != 0) {
 145                         TALLOC_FREE(frame);
 146                         return ret;
 147                 }
 148                 TALLOC_FREE(frame);
 149         }
 150
 151         return ret;
 152 }
 153
 154 static int fake_acls_lstat(vfs_handle_struct *handle,
 155                            struct smb_filename *smb_fname)
 156 {
 157         int ret = -1;
 158
 159         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 160         if (ret == 0) {
 161                 TALLOC_CTX *frame = talloc_stackframe();
 162                 char *path;
 163                 struct smb_filename smb_fname_base = {
 164                         .base_name = smb_fname->base_name
 165                 };
 166                 NTSTATUS status;
 167                 /*
 168                  * As we're calling getxattr directly here
 169                  * we need to use only the base_name, not
 170                  * the full name containing any stream name.
 171                  */
 172                 status = get_full_smb_filename(frame, &smb_fname_base, &path);
 173                 if (!NT_STATUS_IS_OK(status)) {
 174                         errno = map_errno_from_nt_status(status);
 175                         TALLOC_FREE(frame);
 176                         return -1;
 177                 }
 178
 179                 /* This isn't quite right (calling getxattr not
 180                  * lgetxattr), but for the test purposes of this
 181                  * module (fake NT ACLs from windows clients), it is
 182                  * close enough.  We removed the l*xattr functions
 183                  * because linux doesn't support using them, but we
 184                  * could fake them in xattr_tdb if we really wanted
 185                  * to.  We ignore errors because the link might not point anywhere */
 186                 fake_acls_uid(handle, &smb_fname_base,
 187                         &smb_fname->st.st_ex_uid);
 188                 fake_acls_gid(handle, &smb_fname_base,
 189                         &smb_fname->st.st_ex_gid);
 190                 TALLOC_FREE(frame);
 191         }
 192
 193         return ret;
 194 }
 195
 196 static int fake_acls_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 197 {
 198         int ret = -1;
 199
 200         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
 201         if (ret == 0) {
 202                 ret = fake_acls_fuid(handle, fsp, &sbuf->st_ex_uid);
 203                 if (ret != 0) {
 204                         return ret;
 205                 }
 206                 ret = fake_acls_fgid(handle, fsp, &sbuf->st_ex_gid);
 207                 if (ret != 0) {
 208                         return ret;
 209                 }
 210         }
 211         return ret;
 212 }
 213
 214 static SMB_ACL_T fake_acls_blob2acl(DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 215 {
 216         enum ndr_err_code ndr_err;
 217         struct smb_acl_t *acl = talloc(mem_ctx, struct smb_acl_t);
 218         if (!acl) {
 219                 errno = ENOMEM;
 220                 return NULL;
 221         }
 222
 223         ndr_err = ndr_pull_struct_blob(blob, acl, acl,
 224                 (ndr_pull_flags_fn_t)ndr_pull_smb_acl_t);
 225
 226         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 227                 DEBUG(0, ("ndr_pull_acl_t failed: %s\n",
 228                           ndr_errstr(ndr_err)));
 229                 TALLOC_FREE(acl);
 230                 return NULL;
 231         }
 232         return acl;
 233 }
 234
 235 static DATA_BLOB fake_acls_acl2blob(TALLOC_CTX *mem_ctx, SMB_ACL_T acl)
 236 {
 237         enum ndr_err_code ndr_err;
 238         DATA_BLOB blob;
 239         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, acl,
 240                 (ndr_push_flags_fn_t)ndr_push_smb_acl_t);
 241
 242         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 243                 DEBUG(0, ("ndr_push_acl_t failed: %s\n",
 244                           ndr_errstr(ndr_err)));
 245                 return data_blob_null;
 246         }
 247         return blob;
 248 }
 249
 250 static SMB_ACL_T fake_acls_sys_acl_get_file(struct vfs_handle_struct *handle,
 251                                 const struct smb_filename *smb_fname,
 252                                 SMB_ACL_TYPE_T type,
 253                                 TALLOC_CTX *mem_ctx)
 254 {
 255         DATA_BLOB blob = data_blob_null;
 256         ssize_t length;
 257         const char *name = NULL;
 258         struct smb_acl_t *acl = NULL;
 259         TALLOC_CTX *frame = talloc_stackframe();
 260         switch (type) {
 261         case SMB_ACL_TYPE_ACCESS:
 262                 name = FAKE_ACL_ACCESS_XATTR;
 263                 break;
 264         case SMB_ACL_TYPE_DEFAULT:
 265                 name = FAKE_ACL_DEFAULT_XATTR;
 266                 break;
 267         }
 268
 269         do {
 270                 blob.length += 1000;
 271                 blob.data = talloc_realloc(frame, blob.data, uint8_t, blob.length);
 272                 if (!blob.data) {
 273                         errno = ENOMEM;
 274                         TALLOC_FREE(frame);
 275                         return NULL;
 276                 }
 277                 length = SMB_VFS_NEXT_GETXATTR(handle, smb_fname,
 278                                 name, blob.data, blob.length);
 279                 blob.length = length;
 280         } while (length == -1 && errno == ERANGE);
 281         if (length == -1 && errno == ENOATTR) {
 282                 TALLOC_FREE(frame);
 283                 return NULL;
 284         }
 285         if (length != -1) {
 286                 acl = fake_acls_blob2acl(&blob, mem_ctx);
 287         }
 288         TALLOC_FREE(frame);
 289         return acl;
 290 }
 291
 292 static SMB_ACL_T fake_acls_sys_acl_get_fd(struct vfs_handle_struct *handle,
 293                                           files_struct *fsp,
 294                                           TALLOC_CTX *mem_ctx)
 295 {
 296         DATA_BLOB blob = data_blob_null;
 297         ssize_t length;
 298         const char *name = FAKE_ACL_ACCESS_XATTR;
 299         struct smb_acl_t *acl = NULL;
 300         TALLOC_CTX *frame = talloc_stackframe();
 301
 302         do {
 303                 blob.length += 1000;
 304                 blob.data = talloc_realloc(frame, blob.data, uint8_t, blob.length);
 305                 if (!blob.data) {
 306                         errno = ENOMEM;
 307                         TALLOC_FREE(frame);
 308                         return NULL;
 309                 }
 310                 length = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, blob.data, blob.length);
 311                 blob.length = length;
 312         } while (length == -1 && errno == ERANGE);
 313         if (length == -1 && errno == ENOATTR) {
 314                 TALLOC_FREE(frame);
 315                 return NULL;
 316         }
 317         if (length != -1) {
 318                 acl = fake_acls_blob2acl(&blob, mem_ctx);
 319         }
 320         TALLOC_FREE(frame);
 321         return acl;
 322 }
 323
 324
 325 static int fake_acls_sys_acl_set_file(vfs_handle_struct *handle,
 326                         const struct smb_filename *smb_fname,
 327                         SMB_ACL_TYPE_T acltype,
 328                         SMB_ACL_T theacl)
 329 {
 330         int ret;
 331         const char *name = NULL;
 332         TALLOC_CTX *frame = talloc_stackframe();
 333         DATA_BLOB blob = fake_acls_acl2blob(frame, theacl);
 334         if (!blob.data) {
 335                 DEBUG(0, ("Failed to convert ACL to linear blob for xattr storage\n"));
 336                 TALLOC_FREE(frame);
 337                 errno = EINVAL;
 338                 return -1;
 339         }
 340         switch (acltype) {
 341         case SMB_ACL_TYPE_ACCESS:
 342                 name = FAKE_ACL_ACCESS_XATTR;
 343                 break;
 344         case SMB_ACL_TYPE_DEFAULT:
 345                 name = FAKE_ACL_DEFAULT_XATTR;
 346                 break;
 347         }
 348         ret = SMB_VFS_NEXT_SETXATTR(handle, smb_fname,
 349                         name, blob.data, blob.length, 0);
 350         TALLOC_FREE(frame);
 351         return ret;
 352 }
 353
 354 static int fake_acls_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
 355 {
 356         int ret;
 357         const char *name = FAKE_ACL_ACCESS_XATTR;
 358         TALLOC_CTX *frame = talloc_stackframe();
 359         DATA_BLOB blob = fake_acls_acl2blob(frame, theacl);
 360         if (!blob.data) {
 361                 DEBUG(0, ("Failed to convert ACL to linear blob for xattr storage\n"));
 362                 TALLOC_FREE(frame);
 363                 errno = EINVAL;
 364                 return -1;
 365         }
 366         ret = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, blob.data, blob.length, 0);
 367         TALLOC_FREE(frame);
 368         return ret;
 369 }
 370
 371 static int fake_acls_sys_acl_delete_def_file(vfs_handle_struct *handle,
 372                         const struct smb_filename *smb_fname_in)
 373 {
 374         int ret;
 375         const char *name = FAKE_ACL_DEFAULT_XATTR;
 376         TALLOC_CTX *frame = talloc_stackframe();
 377         struct smb_filename *smb_fname = cp_smb_filename_nostream(talloc_tos(),
 378                                                 smb_fname_in);
 379
 380         if (smb_fname == NULL) {
 381                 TALLOC_FREE(frame);
 382                 errno = ENOMEM;
 383                 return -1;
 384         }
 385
 386         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
 387         if (ret == -1) {
 388                 TALLOC_FREE(frame);
 389                 return -1;
 390         }
 391
 392         if (!S_ISDIR(smb_fname->st.st_ex_mode)) {
 393                 errno = EINVAL;
 394                 TALLOC_FREE(frame);
 395                 return -1;
 396         }
 397
 398         ret = SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, name);
 399         if (ret == -1 && errno == ENOATTR) {
 400                 ret = 0;
 401                 errno = 0;
 402         }
 403
 404         TALLOC_FREE(frame);
 405         return ret;
 406 }
 407
 408 static int fake_acls_chown(vfs_handle_struct *handle,
 409                         const struct smb_filename *smb_fname,
 410                         uid_t uid,
 411                         gid_t gid)
 412 {
 413         int ret;
 414         uint8_t id_buf[4];
 415         if (uid != -1) {
 416                 SIVAL(id_buf, 0, uid);
 417                 ret = SMB_VFS_NEXT_SETXATTR(handle,
 418                                 smb_fname,
 419                                 FAKE_UID,
 420                                 id_buf,
 421                                 sizeof(id_buf),
 422                                 0);
 423                 if (ret != 0) {
 424                         return ret;
 425                 }
 426         }
 427         if (gid != -1) {
 428                 SIVAL(id_buf, 0, gid);
 429                 ret = SMB_VFS_NEXT_SETXATTR(handle,
 430                                 smb_fname,
 431                                 FAKE_GID,
 432                                 id_buf,
 433                                 sizeof(id_buf),
 434                                 0);
 435                 if (ret != 0) {
 436                         return ret;
 437                 }
 438         }
 439         return 0;
 440 }
 441
 442 static int fake_acls_lchown(vfs_handle_struct *handle,
 443                         const struct smb_filename *smb_fname,
 444                         uid_t uid,
 445                         gid_t gid)
 446 {
 447         int ret;
 448         uint8_t id_buf[4];
 449         if (uid != -1) {
 450                 /* This isn't quite right (calling setxattr not
 451                  * lsetxattr), but for the test purposes of this
 452                  * module (fake NT ACLs from windows clients), it is
 453                  * close enough.  We removed the l*xattr functions
 454                  * because linux doesn't support using them, but we
 455                  * could fake them in xattr_tdb if we really wanted
 456                  * to.
 457                  */
 458                 SIVAL(id_buf, 0, uid);
 459                 ret = SMB_VFS_NEXT_SETXATTR(handle,
 460                                 smb_fname,
 461                                 FAKE_UID,
 462                                 id_buf,
 463                                 sizeof(id_buf),
 464                                 0);
 465                 if (ret != 0) {
 466                         return ret;
 467                 }
 468         }
 469         if (gid != -1) {
 470                 SIVAL(id_buf, 0, gid);
 471                 ret = SMB_VFS_NEXT_SETXATTR(handle,
 472                                 smb_fname,
 473                                 FAKE_GID,
 474                                 id_buf,
 475                                 sizeof(id_buf),
 476                                 0);
 477                 if (ret != 0) {
 478                         return ret;
 479                 }
 480         }
 481         return 0;
 482 }
 483
 484 static int fake_acls_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
 485 {
 486         int ret;
 487         uint8_t id_buf[4];
 488         if (uid != -1) {
 489                 SIVAL(id_buf, 0, uid);
 490                 ret = SMB_VFS_NEXT_FSETXATTR(handle, fsp, FAKE_UID, id_buf, sizeof(id_buf), 0);
 491                 if (ret != 0) {
 492                         return ret;
 493                 }
 494         }
 495         if (gid != -1) {
 496                 SIVAL(id_buf, 0, gid);
 497                 ret = SMB_VFS_NEXT_FSETXATTR(handle, fsp, FAKE_GID, id_buf, sizeof(id_buf), 0);
 498                 if (ret != 0) {
 499                         return ret;
 500                 }
 501         }
 502         return 0;
 503 }
 504
 505
 506 static struct vfs_fn_pointers vfs_fake_acls_fns = {
 507         .stat_fn = fake_acls_stat,
 508         .lstat_fn = fake_acls_lstat,
 509         .fstat_fn = fake_acls_fstat,
 510         .sys_acl_get_file_fn = fake_acls_sys_acl_get_file,
 511         .sys_acl_get_fd_fn = fake_acls_sys_acl_get_fd,
 512         .sys_acl_blob_get_file_fn = posix_sys_acl_blob_get_file,
 513         .sys_acl_blob_get_fd_fn = posix_sys_acl_blob_get_fd,
 514         .sys_acl_set_file_fn = fake_acls_sys_acl_set_file,
 515         .sys_acl_set_fd_fn = fake_acls_sys_acl_set_fd,
 516         .sys_acl_delete_def_file_fn = fake_acls_sys_acl_delete_def_file,
 517         .chown_fn = fake_acls_chown,
 518         .lchown_fn = fake_acls_lchown,
 519         .fchown_fn = fake_acls_fchown,
 520
 521 };
 522
 523 NTSTATUS vfs_fake_acls_init(TALLOC_CTX *);
 524 NTSTATUS vfs_fake_acls_init(TALLOC_CTX *ctx)
 525 {
 526         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_acls",
 527                                 &vfs_fake_acls_fns);
 528 }