source/smbd/dosmode.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    dos mode handling functions
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) James Peach 2006
   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 "includes.h"
  23
  24 static int set_sparse_flag(const SMB_STRUCT_STAT * const sbuf)
  25 {
  26 #if defined (HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
  27         if (sbuf->st_size > sbuf->st_blocks * (SMB_OFF_T)STAT_ST_BLOCKSIZE) {
  28                 return FILE_ATTRIBUTE_SPARSE;
  29         }
  30 #endif
  31         return 0;
  32 }
  33
  34 /****************************************************************************
  35  Work out whether this file is offline
  36 ****************************************************************************/
  37
  38 #ifndef ISDOT
  39 #define ISDOT(p) (*(p) == '.' && *((p) + 1) == '\0')
  40 #endif /* ISDOT */
  41
  42 #ifndef ISDOTDOT
  43 #define ISDOTDOT(p) (*(p) == '.' && *((p) + 1) == '.' && *((p) + 2) == '\0')
  44 #endif /* ISDOTDOT */
  45
  46 static uint32 set_offline_flag(connection_struct *conn, const char *const path)
  47 {
  48         if (ISDOT(path) || ISDOTDOT(path)) {
  49                 return 0;
  50         }
  51
  52         if (!lp_dmapi_support(SNUM(conn)) || !dmapi_have_session()) {
  53                 return 0;
  54         }
  55
  56         return dmapi_file_flags(path);
  57 }
  58
  59 /****************************************************************************
  60  Change a dos mode to a unix mode.
  61     Base permission for files:
  62          if creating file and inheriting
  63            apply read/write bits from parent directory.
  64          else
  65            everybody gets read bit set
  66          dos readonly is represented in unix by removing everyone's write bit
  67          dos archive is represented in unix by the user's execute bit
  68          dos system is represented in unix by the group's execute bit
  69          dos hidden is represented in unix by the other's execute bit
  70          if !inheriting {
  71            Then apply create mask,
  72            then add force bits.
  73          }
  74     Base permission for directories:
  75          dos directory is represented in unix by unix's dir bit and the exec bit
  76          if !inheriting {
  77            Then apply create mask,
  78            then add force bits.
  79          }
  80 ****************************************************************************/
  81
  82 mode_t unix_mode(connection_struct *conn, int dosmode, const char *fname, BOOL creating_file)
  83 {
  84         mode_t result = (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH);
  85         mode_t dir_mode = 0; /* Mode of the parent directory if inheriting. */
  86
  87         if (!lp_store_dos_attributes(SNUM(conn)) && IS_DOS_READONLY(dosmode)) {
  88                 result &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
  89         }
  90
  91         if (fname && creating_file && lp_inherit_perms(SNUM(conn))) {
  92                 char *dname;
  93                 SMB_STRUCT_STAT sbuf;
  94
  95                 dname = parent_dirname(fname);
  96                 DEBUG(2,("unix_mode(%s) inheriting from %s\n",fname,dname));
  97                 if (SMB_VFS_STAT(conn,dname,&sbuf) != 0) {
  98                         DEBUG(4,("unix_mode(%s) failed, [dir %s]: %s\n",fname,dname,strerror(errno)));
  99                         return(0);      /* *** shouldn't happen! *** */
 100                 }
 101
 102                 /* Save for later - but explicitly remove setuid bit for safety. */
 103                 dir_mode = sbuf.st_mode & ~S_ISUID;
 104                 DEBUG(2,("unix_mode(%s) inherit mode %o\n",fname,(int)dir_mode));
 105                 /* Clear "result" */
 106                 result = 0;
 107         }
 108
 109         if (IS_DOS_DIR(dosmode)) {
 110                 /* We never make directories read only for the owner as under DOS a user
 111                 can always create a file in a read-only directory. */
 112                 result |= (S_IFDIR | S_IWUSR);
 113
 114                 if (dir_mode) {
 115                         /* Inherit mode of parent directory. */
 116                         result |= dir_mode;
 117                 } else {
 118                         /* Provisionally add all 'x' bits */
 119                         result |= (S_IXUSR | S_IXGRP | S_IXOTH);
 120
 121                         /* Apply directory mask */
 122                         result &= lp_dir_mask(SNUM(conn));
 123                         /* Add in force bits */
 124                         result |= lp_force_dir_mode(SNUM(conn));
 125                 }
 126         } else {
 127                 if (lp_map_archive(SNUM(conn)) && IS_DOS_ARCHIVE(dosmode))
 128                         result |= S_IXUSR;
 129
 130                 if (lp_map_system(SNUM(conn)) && IS_DOS_SYSTEM(dosmode))
 131                         result |= S_IXGRP;
 132
 133                 if (lp_map_hidden(SNUM(conn)) && IS_DOS_HIDDEN(dosmode))
 134                         result |= S_IXOTH;
 135
 136                 if (dir_mode) {
 137                         /* Inherit 666 component of parent directory mode */
 138                         result |= dir_mode & (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH);
 139                 } else {
 140                         /* Apply mode mask */
 141                         result &= lp_create_mask(SNUM(conn));
 142                         /* Add in force bits */
 143                         result |= lp_force_create_mode(SNUM(conn));
 144                 }
 145         }
 146
 147         DEBUG(3,("unix_mode(%s) returning 0%o\n",fname,(int)result ));
 148         return(result);
 149 }
 150
 151 /****************************************************************************
 152  Change a unix mode to a dos mode.
 153 ****************************************************************************/
 154
 155 static uint32 dos_mode_from_sbuf(connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 156 {
 157         int result = 0;
 158         enum mapreadonly_options ro_opts = (enum mapreadonly_options)lp_map_readonly(SNUM(conn));
 159
 160         if (ro_opts == MAP_READONLY_YES) {
 161                 /* Original Samba method - map inverse of user "w" bit. */
 162                 if ((sbuf->st_mode & S_IWUSR) == 0) {
 163                         result |= aRONLY;
 164                 }
 165         } else if (ro_opts == MAP_READONLY_PERMISSIONS) {
 166                 /* Check actual permissions for read-only. */
 167                 if (!can_write_to_file(conn, path, sbuf)) {
 168                         result |= aRONLY;
 169                 }
 170         } /* Else never set the readonly bit. */
 171
 172         if (MAP_ARCHIVE(conn) && ((sbuf->st_mode & S_IXUSR) != 0))
 173                 result |= aARCH;
 174
 175         if (MAP_SYSTEM(conn) && ((sbuf->st_mode & S_IXGRP) != 0))
 176                 result |= aSYSTEM;
 177
 178         if (MAP_HIDDEN(conn) && ((sbuf->st_mode & S_IXOTH) != 0))
 179                 result |= aHIDDEN;
 180
 181         if (S_ISDIR(sbuf->st_mode))
 182                 result = aDIR | (result & aRONLY);
 183
 184         result |= set_sparse_flag(sbuf);
 185
 186 #ifdef S_ISLNK
 187 #if LINKS_READ_ONLY
 188         if (S_ISLNK(sbuf->st_mode) && S_ISDIR(sbuf->st_mode))
 189                 result |= aRONLY;
 190 #endif
 191 #endif
 192
 193         DEBUG(8,("dos_mode_from_sbuf returning "));
 194
 195         if (result & aHIDDEN) DEBUG(8, ("h"));
 196         if (result & aRONLY ) DEBUG(8, ("r"));
 197         if (result & aSYSTEM) DEBUG(8, ("s"));
 198         if (result & aDIR   ) DEBUG(8, ("d"));
 199         if (result & aARCH  ) DEBUG(8, ("a"));
 200
 201         DEBUG(8,("\n"));
 202         return result;
 203 }
 204
 205 /****************************************************************************
 206  Get DOS attributes from an EA.
 207 ****************************************************************************/
 208
 209 static BOOL get_ea_dos_attribute(connection_struct *conn, const char *path,SMB_STRUCT_STAT *sbuf, uint32 *pattr)
 210 {
 211         ssize_t sizeret;
 212         fstring attrstr;
 213         unsigned int dosattr;
 214
 215         if (!lp_store_dos_attributes(SNUM(conn))) {
 216                 return False;
 217         }
 218
 219         /* Don't reset pattr to zero as we may already have filename-based attributes we
 220            need to preserve. */
 221
 222         sizeret = SMB_VFS_GETXATTR(conn, path, SAMBA_XATTR_DOS_ATTRIB, attrstr, sizeof(attrstr));
 223         if (sizeret == -1) {
 224 #if defined(ENOTSUP) && defined(ENOATTR)
 225                 if ((errno != ENOTSUP) && (errno != ENOATTR) && (errno != EACCES) && (errno != EPERM)) {
 226                         DEBUG(1,("get_ea_dos_attributes: Cannot get attribute from EA on file %s: Error = %s\n",
 227                                 path, strerror(errno) ));
 228                         set_store_dos_attributes(SNUM(conn), False);
 229                 }
 230 #endif
 231                 return False;
 232         }
 233         /* Null terminate string. */
 234         attrstr[sizeret] = 0;
 235         DEBUG(10,("get_ea_dos_attribute: %s attrstr = %s\n", path, attrstr));
 236
 237         if (sizeret < 2 || attrstr[0] != '0' || attrstr[1] != 'x' ||
 238                         sscanf(attrstr, "%x", &dosattr) != 1) {
 239                 DEBUG(1,("get_ea_dos_attributes: Badly formed DOSATTRIB on file %s - %s\n", path, attrstr));
 240                 return False;
 241         }
 242
 243         if (S_ISDIR(sbuf->st_mode)) {
 244                 dosattr |= aDIR;
 245         }
 246         *pattr = (uint32)(dosattr & SAMBA_ATTRIBUTES_MASK);
 247
 248         DEBUG(8,("get_ea_dos_attribute returning (0x%x)", dosattr));
 249
 250         if (dosattr & aHIDDEN) DEBUG(8, ("h"));
 251         if (dosattr & aRONLY ) DEBUG(8, ("r"));
 252         if (dosattr & aSYSTEM) DEBUG(8, ("s"));
 253         if (dosattr & aDIR   ) DEBUG(8, ("d"));
 254         if (dosattr & aARCH  ) DEBUG(8, ("a"));
 255
 256         DEBUG(8,("\n"));
 257
 258         return True;
 259 }
 260
 261 /****************************************************************************
 262  Set DOS attributes in an EA.
 263 ****************************************************************************/
 264
 265 static BOOL set_ea_dos_attribute(connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf, uint32 dosmode)
 266 {
 267         fstring attrstr;
 268         files_struct *fsp = NULL;
 269         BOOL ret = False;
 270
 271         if (!lp_store_dos_attributes(SNUM(conn))) {
 272                 return False;
 273         }
 274
 275         snprintf(attrstr, sizeof(attrstr)-1, "0x%x", dosmode & SAMBA_ATTRIBUTES_MASK);
 276         if (SMB_VFS_SETXATTR(conn, path, SAMBA_XATTR_DOS_ATTRIB, attrstr, strlen(attrstr), 0) == -1) {
 277                 if((errno != EPERM) && (errno != EACCES)) {
 278                         if (errno == ENOSYS
 279 #if defined(ENOTSUP)
 280                                 || errno == ENOTSUP) {
 281 #else
 282                                 ) {
 283 #endif
 284                                 set_store_dos_attributes(SNUM(conn), False);
 285                         }
 286                         return False;
 287                 }
 288
 289                 /* We want DOS semantics, ie allow non owner with write permission to change the
 290                         bits on a file. Just like file_utime below.
 291                 */
 292
 293                 /* Check if we have write access. */
 294                 if(!CAN_WRITE(conn) || !lp_dos_filemode(SNUM(conn)))
 295                         return False;
 296
 297                 /*
 298                  * We need to open the file with write access whilst
 299                  * still in our current user context. This ensures we
 300                  * are not violating security in doing the setxattr.
 301                  */
 302
 303                 fsp = open_file_fchmod(conn,path,sbuf);
 304                 if (!fsp)
 305                         return ret;
 306                 become_root();
 307                 if (SMB_VFS_SETXATTR(conn, path, SAMBA_XATTR_DOS_ATTRIB, attrstr, strlen(attrstr), 0) == 0) {
 308                         ret = True;
 309                 }
 310                 unbecome_root();
 311                 close_file_fchmod(fsp);
 312                 return ret;
 313         }
 314         DEBUG(10,("set_ea_dos_attribute: set EA %s on file %s\n", attrstr, path));
 315         return True;
 316 }
 317
 318 /****************************************************************************
 319  Change a unix mode to a dos mode.
 320 ****************************************************************************/
 321
 322 uint32 dos_mode(connection_struct *conn, const char *path,SMB_STRUCT_STAT *sbuf)
 323 {
 324         uint32 result = 0;
 325
 326         DEBUG(8,("dos_mode: %s\n", path));
 327
 328         if (!VALID_STAT(*sbuf)) {
 329                 return 0;
 330         }
 331
 332         /* First do any modifications that depend on the path name. */
 333         /* hide files with a name starting with a . */
 334         if (lp_hide_dot_files(SNUM(conn))) {
 335                 const char *p = strrchr_m(path,'/');
 336                 if (p) {
 337                         p++;
 338                 } else {
 339                         p = path;
 340                 }
 341
 342                 if (p[0] == '.' && p[1] != '.' && p[1] != 0) {
 343                         result |= aHIDDEN;
 344                 }
 345         }
 346
 347         /* Get the DOS attributes from an EA by preference. */
 348         if (get_ea_dos_attribute(conn, path, sbuf, &result)) {
 349                 result |= set_sparse_flag(sbuf);
 350         } else {
 351                 result |= dos_mode_from_sbuf(conn, path, sbuf);
 352         }
 353
 354         if (S_ISREG(sbuf->st_mode)) {
 355                 result |= set_offline_flag(conn, path);
 356         }
 357
 358         /* Optimization : Only call is_hidden_path if it's not already
 359            hidden. */
 360         if (!(result & aHIDDEN) && IS_HIDDEN_PATH(conn,path)) {
 361                 result |= aHIDDEN;
 362         }
 363
 364         DEBUG(8,("dos_mode returning "));
 365
 366         if (result & aHIDDEN) DEBUG(8, ("h"));
 367         if (result & aRONLY ) DEBUG(8, ("r"));
 368         if (result & aSYSTEM) DEBUG(8, ("s"));
 369         if (result & aDIR   ) DEBUG(8, ("d"));
 370         if (result & aARCH  ) DEBUG(8, ("a"));
 371         if (result & FILE_ATTRIBUTE_SPARSE ) DEBUG(8, ("[sparse]"));
 372
 373         DEBUG(8,("\n"));
 374
 375         return(result);
 376 }
 377
 378 /*******************************************************************
 379  chmod a file - but preserve some bits.
 380 ********************************************************************/
 381
 382 int file_set_dosmode(connection_struct *conn, const char *fname, uint32 dosmode, SMB_STRUCT_STAT *st, BOOL creating_file)
 383 {
 384         SMB_STRUCT_STAT st1;
 385         int mask=0;
 386         mode_t tmp;
 387         mode_t unixmode;
 388         int ret = -1;
 389
 390         /* We only allow READONLY|HIDDEN|SYSTEM|DIRECTORY|ARCHIVE here. */
 391         dosmode &= SAMBA_ATTRIBUTES_MASK;
 392
 393         DEBUG(10,("file_set_dosmode: setting dos mode 0x%x on file %s\n", dosmode, fname));
 394         if (!st || (st && !VALID_STAT(*st))) {
 395                 st = &st1;
 396                 if (SMB_VFS_STAT(conn,fname,st))
 397                         return(-1);
 398         }
 399
 400         get_acl_group_bits(conn, fname, &st->st_mode);
 401
 402         if (S_ISDIR(st->st_mode))
 403                 dosmode |= aDIR;
 404         else
 405                 dosmode &= ~aDIR;
 406
 407         if (dos_mode(conn,fname,st) == dosmode)
 408                 return(0);
 409
 410         /* Store the DOS attributes in an EA by preference. */
 411         if (set_ea_dos_attribute(conn, fname, st, dosmode)) {
 412                 return 0;
 413         }
 414
 415         unixmode = unix_mode(conn,dosmode,fname, creating_file);
 416
 417         /* preserve the s bits */
 418         mask |= (S_ISUID | S_ISGID);
 419
 420         /* preserve the t bit */
 421 #ifdef S_ISVTX
 422         mask |= S_ISVTX;
 423 #endif
 424
 425         /* possibly preserve the x bits */
 426         if (!MAP_ARCHIVE(conn))
 427                 mask |= S_IXUSR;
 428         if (!MAP_SYSTEM(conn))
 429                 mask |= S_IXGRP;
 430         if (!MAP_HIDDEN(conn))
 431                 mask |= S_IXOTH;
 432
 433         unixmode |= (st->st_mode & mask);
 434
 435         /* if we previously had any r bits set then leave them alone */
 436         if ((tmp = st->st_mode & (S_IRUSR|S_IRGRP|S_IROTH))) {
 437                 unixmode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
 438                 unixmode |= tmp;
 439         }
 440
 441         /* if we previously had any w bits set then leave them alone
 442                 whilst adding in the new w bits, if the new mode is not rdonly */
 443         if (!IS_DOS_READONLY(dosmode)) {
 444                 unixmode |= (st->st_mode & (S_IWUSR|S_IWGRP|S_IWOTH));
 445         }
 446
 447         if ((ret = SMB_VFS_CHMOD(conn,fname,unixmode)) == 0)
 448                 return 0;
 449
 450         if((errno != EPERM) && (errno != EACCES))
 451                 return -1;
 452
 453         if(!lp_dos_filemode(SNUM(conn)))
 454                 return -1;
 455
 456         /* We want DOS semantics, ie allow non owner with write permission to change the
 457                 bits on a file. Just like file_utime below.
 458         */
 459
 460         /* Check if we have write access. */
 461         if (CAN_WRITE(conn)) {
 462                 /*
 463                  * We need to open the file with write access whilst
 464                  * still in our current user context. This ensures we
 465                  * are not violating security in doing the fchmod.
 466                  * This file open does *not* break any oplocks we are
 467                  * holding. We need to review this.... may need to
 468                  * break batch oplocks open by others. JRA.
 469                  */
 470                 files_struct *fsp = open_file_fchmod(conn,fname,st);
 471                 if (!fsp)
 472                         return -1;
 473                 become_root();
 474                 ret = SMB_VFS_FCHMOD(fsp, fsp->fh->fd, unixmode);
 475                 unbecome_root();
 476                 close_file_fchmod(fsp);
 477         }
 478
 479         return( ret );
 480 }
 481
 482 /*******************************************************************
 483  Wrapper around dos_utime that possibly allows DOS semantics rather
 484  than POSIX.
 485 *******************************************************************/
 486
 487 int file_utime(connection_struct *conn, const char *fname, struct utimbuf *times)
 488 {
 489         SMB_STRUCT_STAT sbuf;
 490         int ret = -1;
 491
 492         errno = 0;
 493         ZERO_STRUCT(sbuf);
 494
 495         /* Don't update the time on read-only shares */
 496         /* We need this as set_filetime (which can be called on
 497            close and other paths) can end up calling this function
 498            without the NEED_WRITE protection. Found by :
 499            Leo Weppelman <leo@wau.mis.ah.nl>
 500         */
 501
 502         if (!CAN_WRITE(conn)) {
 503                 return 0;
 504         }
 505
 506         if(SMB_VFS_UTIME(conn,fname, times) == 0)
 507                 return 0;
 508
 509         if((errno != EPERM) && (errno != EACCES))
 510                 return -1;
 511
 512         if(!lp_dos_filetimes(SNUM(conn)))
 513                 return -1;
 514
 515         /* We have permission (given by the Samba admin) to
 516            break POSIX semantics and allow a user to change
 517            the time on a file they don't own but can write to
 518            (as DOS does).
 519          */
 520
 521         /* Check if we have write access. */
 522         if (can_write_to_file(conn, fname, &sbuf)) {
 523                 /* We are allowed to become root and change the filetime. */
 524                 become_root();
 525                 ret = SMB_VFS_UTIME(conn,fname, times);
 526                 unbecome_root();
 527         }
 528
 529         return ret;
 530 }
 531
 532 /*******************************************************************
 533  Change a filetime - possibly allowing DOS semantics.
 534 *******************************************************************/
 535
 536 BOOL set_filetime(connection_struct *conn, const char *fname, time_t mtime)
 537 {
 538         struct utimbuf times;
 539
 540         if (null_mtime(mtime))
 541                 return(True);
 542
 543         times.modtime = times.actime = mtime;
 544
 545         if (file_utime(conn, fname, &times)) {
 546                 DEBUG(4,("set_filetime(%s) failed: %s\n",fname,strerror(errno)));
 547                 return False;
 548         }
 549
 550         return(True);
 551 }