source/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 (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 int 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 #ifdef S_ISLNK
 140 #if LINKS_READ_ONLY
 141   if (S_ISLNK(sbuf->st_mode) && S_ISDIR(sbuf->st_mode))
 142     result |= aRONLY;
 143 #endif
 144 #endif
 145
 146   /* hide files with a name starting with a . */
 147   if (lp_hide_dot_files(SNUM(conn)))
 148     {
 149       char *p = strrchr_m(path,'/');
 150       if (p)
 151         p++;
 152       else
 153         p = path;
 154
 155       if (p[0] == '.' && p[1] != '.' && p[1] != 0)
 156         result |= aHIDDEN;
 157     }
 158
 159   /* Optimization : Only call is_hidden_path if it's not already
 160      hidden. */
 161   if (!(result & aHIDDEN) && IS_HIDDEN_PATH(conn,path))
 162   {
 163     result |= aHIDDEN;
 164   }
 165
 166   DEBUG(8,("dos_mode returning "));
 167
 168   if (result & aHIDDEN) DEBUG(8, ("h"));
 169   if (result & aRONLY ) DEBUG(8, ("r"));
 170   if (result & aSYSTEM) DEBUG(8, ("s"));
 171   if (result & aDIR   ) DEBUG(8, ("d"));
 172   if (result & aARCH  ) DEBUG(8, ("a"));
 173
 174   DEBUG(8,("\n"));
 175
 176   return(result);
 177 }
 178
 179 /*******************************************************************
 180 chmod a file - but preserve some bits
 181 ********************************************************************/
 182 int file_chmod(connection_struct *conn,char *fname,int dosmode,SMB_STRUCT_STAT *st)
 183 {
 184         SMB_STRUCT_STAT st1;
 185         int mask=0;
 186         mode_t tmp;
 187         mode_t unixmode;
 188         int ret = -1;
 189
 190         if (!st) {
 191                 st = &st1;
 192                 if (vfs_stat(conn,fname,st))
 193                         return(-1);
 194         }
 195
 196         if (S_ISDIR(st->st_mode))
 197                 dosmode |= aDIR;
 198         else
 199                 dosmode &= ~aDIR;
 200
 201         if (dos_mode(conn,fname,st) == dosmode)
 202                 return(0);
 203
 204         unixmode = unix_mode(conn,dosmode,fname);
 205
 206         /* preserve the s bits */
 207         mask |= (S_ISUID | S_ISGID);
 208
 209         /* preserve the t bit */
 210 #ifdef S_ISVTX
 211         mask |= S_ISVTX;
 212 #endif
 213
 214         /* possibly preserve the x bits */
 215         if (!MAP_ARCHIVE(conn))
 216                 mask |= S_IXUSR;
 217         if (!MAP_SYSTEM(conn))
 218                 mask |= S_IXGRP;
 219         if (!MAP_HIDDEN(conn))
 220                 mask |= S_IXOTH;
 221
 222         unixmode |= (st->st_mode & mask);
 223
 224         /* if we previously had any r bits set then leave them alone */
 225         if ((tmp = st->st_mode & (S_IRUSR|S_IRGRP|S_IROTH))) {
 226                 unixmode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
 227                 unixmode |= tmp;
 228         }
 229
 230         /* if we previously had any w bits set then leave them alone
 231                 whilst adding in the new w bits, if the new mode is not rdonly */
 232         if (!IS_DOS_READONLY(dosmode)) {
 233                 unixmode |= (st->st_mode & (S_IWUSR|S_IWGRP|S_IWOTH));
 234         }
 235
 236         if ((ret = vfs_chmod(conn,fname,unixmode)) == 0)
 237                 return 0;
 238
 239         if((errno != EPERM) && (errno != EACCES))
 240                 return -1;
 241
 242         if(!lp_dos_filemode(SNUM(conn)))
 243                 return -1;
 244
 245         /* We want DOS semantics, ie allow non owner with write permission to change the
 246                 bits on a file. Just like file_utime below.
 247         */
 248
 249         /* Check if we have write access. */
 250         if (CAN_WRITE(conn)) {
 251                 /*
 252                  * We need to open the file with write access whilst
 253                  * still in our current user context. This ensures we
 254                  * are not violating security in doing the fchmod.
 255                  * This file open does *not* break any oplocks we are
 256                  * holding. We need to review this.... may need to
 257                  * break batch oplocks open by others. JRA.
 258                  */
 259                 files_struct *fsp = open_file_fchmod(conn,fname,st);
 260                 if (!fsp)
 261                         return -1;
 262                 become_root();
 263                 ret = conn->vfs_ops.fchmod(fsp, fsp->fd, unixmode);
 264                 unbecome_root();
 265                 close_file_fchmod(fsp);
 266         }
 267
 268         return( ret );
 269 }
 270
 271
 272 /*******************************************************************
 273 Wrapper around dos_utime that possibly allows DOS semantics rather
 274 than POSIX.
 275 *******************************************************************/
 276 int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
 277 {
 278   extern struct current_user current_user;
 279   SMB_STRUCT_STAT sb;
 280   int ret = -1;
 281
 282   errno = 0;
 283
 284   if(conn->vfs_ops.utime(conn,fname, times) == 0)
 285     return 0;
 286
 287   if((errno != EPERM) && (errno != EACCES))
 288     return -1;
 289
 290   if(!lp_dos_filetimes(SNUM(conn)))
 291     return -1;
 292
 293   /* We have permission (given by the Samba admin) to
 294      break POSIX semantics and allow a user to change
 295      the time on a file they don't own but can write to
 296      (as DOS does).
 297    */
 298
 299   if(vfs_stat(conn,fname,&sb) != 0)
 300     return -1;
 301
 302   /* Check if we have write access. */
 303   if (CAN_WRITE(conn)) {
 304           if (((sb.st_mode & S_IWOTH) ||
 305                conn->admin_user ||
 306                ((sb.st_mode & S_IWUSR) && current_user.uid==sb.st_uid) ||
 307                ((sb.st_mode & S_IWGRP) &&
 308                 in_group(sb.st_gid,current_user.gid,
 309                          current_user.ngroups,current_user.groups)))) {
 310                   /* We are allowed to become root and change the filetime. */
 311                   become_root();
 312                   ret = conn->vfs_ops.utime(conn,fname, times);
 313                   unbecome_root();
 314           }
 315   }
 316
 317   return ret;
 318 }
 319
 320 /*******************************************************************
 321 Change a filetime - possibly allowing DOS semantics.
 322 *******************************************************************/
 323 BOOL set_filetime(connection_struct *conn, char *fname, time_t mtime)
 324 {
 325   struct utimbuf times;
 326
 327   if (null_mtime(mtime)) return(True);
 328
 329   times.modtime = times.actime = mtime;
 330
 331   if (file_utime(conn, fname, &times)) {
 332     DEBUG(4,("set_filetime(%s) failed: %s\n",fname,strerror(errno)));
 333     return False;
 334   }
 335
 336   return(True);
 337 }