source3/smbd/dosmode.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    dos mode handling functions
   4    Copyright (C) Andrew Tridgell 1992-1998
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /****************************************************************************
  24   change a dos mode to a unix mode
  25     base permission for files:
  26          if inheriting
  27            apply read/write bits from parent directory.
  28          else
  29            everybody gets read bit set
  30          dos readonly is represented in unix by removing everyone's write bit
  31          dos archive is represented in unix by the user's execute bit
  32          dos system is represented in unix by the group's execute bit
  33          dos hidden is represented in unix by the other's execute bit
  34          if !inheriting {
  35            Then apply create mask,
  36            then add force bits.
  37          }
  38     base permission for directories:
  39          dos directory is represented in unix by unix's dir bit and the exec bit
  40          if !inheriting {
  41            Then apply create mask,
  42            then add force bits.
  43          }
  44 ****************************************************************************/
  45 mode_t unix_mode(connection_struct *conn,int dosmode,const char *fname)
  46 {
  47   mode_t result = (S_IRUSR | S_IRGRP | S_IROTH);
  48   mode_t dir_mode = 0; /* Mode of the parent directory if inheriting. */
  49
  50   if ( !IS_DOS_READONLY(dosmode) )
  51     result |= (S_IWUSR | S_IWGRP | S_IWOTH);
  52
  53   if (fname && lp_inherit_perms(SNUM(conn))) {
  54     char *dname;
  55     SMB_STRUCT_STAT sbuf;
  56
  57     dname = parent_dirname(fname);
  58     DEBUG(2,("unix_mode(%s) inheriting from %s\n",fname,dname));
  59     if (SMB_VFS_STAT(conn,dname,&sbuf) != 0) {
  60       DEBUG(4,("unix_mode(%s) failed, [dir %s]: %s\n",fname,dname,strerror(errno)));
  61       return(0);      /* *** shouldn't happen! *** */
  62     }
  63
  64     /* Save for later - but explicitly remove setuid bit for safety. */
  65     dir_mode = sbuf.st_mode & ~S_ISUID;
  66     DEBUG(2,("unix_mode(%s) inherit mode %o\n",fname,(int)dir_mode));
  67     /* Clear "result" */
  68     result = 0;
  69   }
  70
  71   if (IS_DOS_DIR(dosmode)) {
  72     /* We never make directories read only for the owner as under DOS a user
  73        can always create a file in a read-only directory. */
  74     result |= (S_IFDIR | S_IWUSR);
  75
  76     if (dir_mode) {
  77       /* Inherit mode of parent directory. */
  78       result |= dir_mode;
  79     } else {
  80       /* Provisionally add all 'x' bits */
  81       result |= (S_IXUSR | S_IXGRP | S_IXOTH);
  82
  83       /* Apply directory mask */
  84       result &= lp_dir_mask(SNUM(conn));
  85       /* Add in force bits */
  86       result |= lp_force_dir_mode(SNUM(conn));
  87     }
  88   } else {
  89     if (lp_map_archive(SNUM(conn)) && IS_DOS_ARCHIVE(dosmode))
  90       result |= S_IXUSR;
  91
  92     if (lp_map_system(SNUM(conn)) && IS_DOS_SYSTEM(dosmode))
  93       result |= S_IXGRP;
  94
  95     if (lp_map_hidden(SNUM(conn)) && IS_DOS_HIDDEN(dosmode))
  96       result |= S_IXOTH;
  97
  98     if (dir_mode) {
  99       /* Inherit 666 component of parent directory mode */
 100       result |= dir_mode
 101         &  (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH);
 102     } else {
 103       /* Apply mode mask */
 104       result &= lp_create_mask(SNUM(conn));
 105       /* Add in force bits */
 106       result |= lp_force_create_mode(SNUM(conn));
 107     }
 108   }
 109
 110   DEBUG(3,("unix_mode(%s) returning 0%o\n",fname,(int)result ));
 111   return(result);
 112 }
 113
 114
 115 /****************************************************************************
 116   change a unix mode to a dos mode
 117 ****************************************************************************/
 118 uint32 dos_mode(connection_struct *conn,char *path,SMB_STRUCT_STAT *sbuf)
 119 {
 120         int result = 0;
 121
 122         DEBUG(8,("dos_mode: %s\n", path));
 123
 124         if ((sbuf->st_mode & S_IWUSR) == 0)
 125                 result |= aRONLY;
 126
 127         if (MAP_ARCHIVE(conn) && ((sbuf->st_mode & S_IXUSR) != 0))
 128                 result |= aARCH;
 129
 130         if (MAP_SYSTEM(conn) && ((sbuf->st_mode & S_IXGRP) != 0))
 131                 result |= aSYSTEM;
 132
 133         if (MAP_HIDDEN(conn) && ((sbuf->st_mode & S_IXOTH) != 0))
 134                 result |= aHIDDEN;
 135
 136         if (S_ISDIR(sbuf->st_mode))
 137                 result = aDIR | (result & aRONLY);
 138
 139 #if defined (HAVE_STAT_ST_BLOCKS) && defined (HAVE_STAT_ST_BLKSIZE)
 140         if (sbuf->st_size > sbuf->st_blocks * (SMB_OFF_T)sbuf->st_blksize) {
 141                 result |= FILE_ATTRIBUTE_SPARSE;
 142         }
 143 #endif
 144
 145 #ifdef S_ISLNK
 146 #if LINKS_READ_ONLY
 147         if (S_ISLNK(sbuf->st_mode) && S_ISDIR(sbuf->st_mode))
 148                 result |= aRONLY;
 149 #endif
 150 #endif
 151
 152         /* hide files with a name starting with a . */
 153         if (lp_hide_dot_files(SNUM(conn))) {
 154                 char *p = strrchr_m(path,'/');
 155                 if (p)
 156                         p++;
 157                 else
 158                         p = path;
 159
 160                 if (p[0] == '.' && p[1] != '.' && p[1] != 0)
 161                         result |= aHIDDEN;
 162         }
 163
 164         /* Optimization : Only call is_hidden_path if it's not already
 165            hidden. */
 166         if (!(result & aHIDDEN) && IS_HIDDEN_PATH(conn,path)) {
 167                 result |= aHIDDEN;
 168         }
 169
 170         DEBUG(8,("dos_mode returning "));
 171
 172         if (result & aHIDDEN) DEBUG(8, ("h"));
 173         if (result & aRONLY ) DEBUG(8, ("r"));
 174         if (result & aSYSTEM) DEBUG(8, ("s"));
 175         if (result & aDIR   ) DEBUG(8, ("d"));
 176         if (result & aARCH  ) DEBUG(8, ("a"));
 177
 178         DEBUG(8,("\n"));
 179
 180         return(result);
 181 }
 182
 183 /*******************************************************************
 184 chmod a file - but preserve some bits
 185 ********************************************************************/
 186 int file_chmod(connection_struct *conn,char *fname, uint32 dosmode,SMB_STRUCT_STAT *st)
 187 {
 188         SMB_STRUCT_STAT st1;
 189         int mask=0;
 190         mode_t tmp;
 191         mode_t unixmode;
 192         int ret = -1;
 193
 194         if (!st) {
 195                 st = &st1;
 196                 if (SMB_VFS_STAT(conn,fname,st))
 197                         return(-1);
 198         }
 199
 200         if (S_ISDIR(st->st_mode))
 201                 dosmode |= aDIR;
 202         else
 203                 dosmode &= ~aDIR;
 204
 205         if (dos_mode(conn,fname,st) == dosmode)
 206                 return(0);
 207
 208         unixmode = unix_mode(conn,dosmode,fname);
 209
 210         /* preserve the s bits */
 211         mask |= (S_ISUID | S_ISGID);
 212
 213         /* preserve the t bit */
 214 #ifdef S_ISVTX
 215         mask |= S_ISVTX;
 216 #endif
 217
 218         /* possibly preserve the x bits */
 219         if (!MAP_ARCHIVE(conn))
 220                 mask |= S_IXUSR;
 221         if (!MAP_SYSTEM(conn))
 222                 mask |= S_IXGRP;
 223         if (!MAP_HIDDEN(conn))
 224                 mask |= S_IXOTH;
 225
 226         unixmode |= (st->st_mode & mask);
 227
 228         /* if we previously had any r bits set then leave them alone */
 229         if ((tmp = st->st_mode & (S_IRUSR|S_IRGRP|S_IROTH))) {
 230                 unixmode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
 231                 unixmode |= tmp;
 232         }
 233
 234         /* if we previously had any w bits set then leave them alone
 235                 whilst adding in the new w bits, if the new mode is not rdonly */
 236         if (!IS_DOS_READONLY(dosmode)) {
 237                 unixmode |= (st->st_mode & (S_IWUSR|S_IWGRP|S_IWOTH));
 238         }
 239
 240         if ((ret = SMB_VFS_CHMOD(conn,fname,unixmode)) == 0)
 241                 return 0;
 242
 243         if((errno != EPERM) && (errno != EACCES))
 244                 return -1;
 245
 246         if(!lp_dos_filemode(SNUM(conn)))
 247                 return -1;
 248
 249         /* We want DOS semantics, ie allow non owner with write permission to change the
 250                 bits on a file. Just like file_utime below.
 251         */
 252
 253         /* Check if we have write access. */
 254         if (CAN_WRITE(conn)) {
 255                 /*
 256                  * We need to open the file with write access whilst
 257                  * still in our current user context. This ensures we
 258                  * are not violating security in doing the fchmod.
 259                  * This file open does *not* break any oplocks we are
 260                  * holding. We need to review this.... may need to
 261                  * break batch oplocks open by others. JRA.
 262                  */
 263                 files_struct *fsp = open_file_fchmod(conn,fname,st);
 264                 if (!fsp)
 265                         return -1;
 266                 become_root();
 267                 ret = SMB_VFS_FCHMOD(fsp, fsp->fd, unixmode);
 268                 unbecome_root();
 269                 close_file_fchmod(fsp);
 270         }
 271
 272         return( ret );
 273 }
 274
 275
 276 /*******************************************************************
 277 Wrapper around dos_utime that possibly allows DOS semantics rather
 278 than POSIX.
 279 *******************************************************************/
 280 int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
 281 {
 282   extern struct current_user current_user;
 283   SMB_STRUCT_STAT sb;
 284   int ret = -1;
 285
 286   errno = 0;
 287
 288   if(SMB_VFS_UTIME(conn,fname, times) == 0)
 289     return 0;
 290
 291   if((errno != EPERM) && (errno != EACCES))
 292     return -1;
 293
 294   if(!lp_dos_filetimes(SNUM(conn)))
 295     return -1;
 296
 297   /* We have permission (given by the Samba admin) to
 298      break POSIX semantics and allow a user to change
 299      the time on a file they don't own but can write to
 300      (as DOS does).
 301    */
 302
 303   if(SMB_VFS_STAT(conn,fname,&sb) != 0)
 304     return -1;
 305
 306   /* Check if we have write access. */
 307   if (CAN_WRITE(conn)) {
 308           if (((sb.st_mode & S_IWOTH) ||
 309                conn->admin_user ||
 310                ((sb.st_mode & S_IWUSR) && current_user.uid==sb.st_uid) ||
 311                ((sb.st_mode & S_IWGRP) &&
 312                 in_group(sb.st_gid,current_user.gid,
 313                          current_user.ngroups,current_user.groups)))) {
 314                   /* We are allowed to become root and change the filetime. */
 315                   become_root();
 316                   ret = SMB_VFS_UTIME(conn,fname, times);
 317                   unbecome_root();
 318           }
 319   }
 320
 321   return ret;
 322 }
 323
 324 /*******************************************************************
 325 Change a filetime - possibly allowing DOS semantics.
 326 *******************************************************************/
 327 BOOL set_filetime(connection_struct *conn, char *fname, time_t mtime)
 328 {
 329   struct utimbuf times;
 330
 331   if (null_mtime(mtime)) return(True);
 332
 333   times.modtime = times.actime = mtime;
 334
 335   if (file_utime(conn, fname, &times)) {
 336     DEBUG(4,("set_filetime(%s) failed: %s\n",fname,strerror(errno)));
 337     return False;
 338   }
 339
 340   return(True);
 341 }