source3/smbd/fileio.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    read/write to a files_struct
   5    Copyright (C) Andrew Tridgell 1992-1998
   6    Copyright (C) Jeremy Allison 2000-2002. - write cache.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "printing.h"
  24 #include "smbd/smbd.h"
  25 #include "smbd/globals.h"
  26 #include "smbprofile.h"
  27
  28 /****************************************************************************
  29  Read from a file.
  30 ****************************************************************************/
  31
  32 ssize_t read_file(files_struct *fsp,char *data,off_t pos,size_t n)
  33 {
  34         ssize_t ret = 0;
  35         bool ok;
  36
  37         /* you can't read from print files */
  38         if (fsp->print_file) {
  39                 errno = EBADF;
  40                 return -1;
  41         }
  42
  43         ok = vfs_valid_pread_range(pos, n);
  44         if (!ok) {
  45                 errno = EINVAL;
  46                 return -1;
  47         }
  48
  49         fsp->fh->pos = pos;
  50
  51         if (n > 0) {
  52                 ret = SMB_VFS_PREAD(fsp,data,n,pos);
  53
  54                 if (ret == -1) {
  55                         return -1;
  56                 }
  57         }
  58
  59         DEBUG(10,("read_file (%s): pos = %.0f, size = %lu, returned %lu\n",
  60                   fsp_str_dbg(fsp), (double)pos, (unsigned long)n, (long)ret));
  61
  62         fsp->fh->pos += ret;
  63         fsp->fh->position_information = fsp->fh->pos;
  64
  65         return(ret);
  66 }
  67
  68 /****************************************************************************
  69  *Really* write to a file.
  70 ****************************************************************************/
  71
  72 static ssize_t real_write_file(struct smb_request *req,
  73                                 files_struct *fsp,
  74                                 const char *data,
  75                                 off_t pos,
  76                                 size_t n)
  77 {
  78         ssize_t ret;
  79         bool ok;
  80
  81         ok = vfs_valid_pwrite_range(pos, n);
  82         if (!ok) {
  83                 errno = EINVAL;
  84                 return -1;
  85         }
  86
  87         if (n == 0) {
  88                 return 0;
  89         }
  90
  91         fsp->fh->pos = pos;
  92         if (pos &&
  93             lp_strict_allocate(SNUM(fsp->conn)) &&
  94             !fsp->fsp_flags.is_sparse)
  95         {
  96                 if (vfs_fill_sparse(fsp, pos) == -1) {
  97                         return -1;
  98                 }
  99         }
 100         ret = vfs_pwrite_data(req, fsp, data, n, pos);
 101
 102         DEBUG(10,("real_write_file (%s): pos = %.0f, size = %lu, returned %ld\n",
 103                   fsp_str_dbg(fsp), (double)pos, (unsigned long)n, (long)ret));
 104
 105         if (ret != -1) {
 106                 fsp->fh->pos += ret;
 107
 108 /* Yes - this is correct - writes don't update this. JRA. */
 109 /* Found by Samba4 tests. */
 110 #if 0
 111                 fsp->position_information = fsp->pos;
 112 #endif
 113         }
 114
 115         return ret;
 116 }
 117
 118 void fsp_flush_write_time_update(struct files_struct *fsp)
 119 {
 120         /*
 121          * Note this won't expect any impersonation!
 122          * So don't call any SMB_VFS operations here!
 123          */
 124
 125         DEBUG(5, ("Update write time on %s\n", fsp_str_dbg(fsp)));
 126
 127         trigger_write_time_update_immediate(fsp);
 128 }
 129
 130 static void update_write_time_handler(struct tevent_context *ctx,
 131                                       struct tevent_timer *te,
 132                                       struct timeval now,
 133                                       void *private_data)
 134 {
 135         files_struct *fsp = (files_struct *)private_data;
 136         fsp_flush_write_time_update(fsp);
 137 }
 138
 139 /*********************************************************
 140  Schedule a write time update for WRITE_TIME_UPDATE_USEC_DELAY
 141  in the future.
 142 *********************************************************/
 143
 144 void trigger_write_time_update(struct files_struct *fsp)
 145 {
 146         int delay;
 147
 148         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 149                 /* Don't use delayed writes on POSIX files. */
 150                 return;
 151         }
 152
 153         if (fsp->fsp_flags.write_time_forced) {
 154                 /* No point - "sticky" write times
 155                  * in effect.
 156                  */
 157                 return;
 158         }
 159
 160         /* We need to remember someone did a write
 161          * and update to current time on close. */
 162
 163         fsp->fsp_flags.update_write_time_on_close = true;
 164
 165         if (fsp->fsp_flags.update_write_time_triggered) {
 166                 /*
 167                  * We only update the write time after 2 seconds
 168                  * on the first normal write. After that
 169                  * no other writes affect this until close.
 170                  */
 171                 return;
 172         }
 173         fsp->fsp_flags.update_write_time_triggered = true;
 174
 175         delay = lp_parm_int(SNUM(fsp->conn),
 176                             "smbd", "writetimeupdatedelay",
 177                             WRITE_TIME_UPDATE_USEC_DELAY);
 178
 179         DEBUG(5, ("Update write time %d usec later on %s\n",
 180                   delay, fsp_str_dbg(fsp)));
 181
 182         /* trigger the update 2 seconds later */
 183         fsp->update_write_time_event =
 184                 tevent_add_timer(fsp->conn->sconn->ev_ctx, NULL,
 185                                  timeval_current_ofs_usec(delay),
 186                                  update_write_time_handler, fsp);
 187 }
 188
 189 void trigger_write_time_update_immediate(struct files_struct *fsp)
 190 {
 191         struct smb_file_time ft;
 192
 193         init_smb_file_time(&ft);
 194
 195         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 196                 /* Don't use delayed writes on POSIX files. */
 197                 return;
 198         }
 199
 200         if (fsp->fsp_flags.write_time_forced) {
 201                 /*
 202                  * No point - "sticky" write times
 203                  * in effect.
 204                  */
 205                 return;
 206         }
 207
 208         TALLOC_FREE(fsp->update_write_time_event);
 209         DEBUG(5, ("Update write time immediate on %s\n",
 210                   fsp_str_dbg(fsp)));
 211
 212         /* After an immediate update, reset the trigger. */
 213         fsp->fsp_flags.update_write_time_triggered = true;
 214         fsp->fsp_flags.update_write_time_on_close = false;
 215
 216         ft.mtime = timespec_current();
 217
 218         /* Update the time in the open file db. */
 219         (void)set_write_time(fsp->file_id, ft.mtime);
 220
 221         /* Now set on disk - takes care of notify. */
 222         (void)smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
 223 }
 224
 225 void mark_file_modified(files_struct *fsp)
 226 {
 227         int dosmode;
 228
 229         trigger_write_time_update(fsp);
 230
 231         if (fsp->fsp_flags.modified) {
 232                 return;
 233         }
 234
 235         fsp->fsp_flags.modified = true;
 236
 237         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 238                 return;
 239         }
 240         if (!(lp_store_dos_attributes(SNUM(fsp->conn)) ||
 241               MAP_ARCHIVE(fsp->conn))) {
 242                 return;
 243         }
 244
 245         dosmode = dos_mode(fsp->conn, fsp->fsp_name);
 246         if (IS_DOS_ARCHIVE(dosmode)) {
 247                 return;
 248         }
 249         file_set_dosmode(fsp->conn, fsp->fsp_name,
 250                          dosmode | FILE_ATTRIBUTE_ARCHIVE, NULL, false);
 251 }
 252
 253 /****************************************************************************
 254  Write to a file.
 255 ****************************************************************************/
 256
 257 ssize_t write_file(struct smb_request *req,
 258                         files_struct *fsp,
 259                         const char *data,
 260                         off_t pos,
 261                         size_t n)
 262 {
 263         ssize_t total_written = 0;
 264
 265         if (fsp->print_file) {
 266                 uint32_t t;
 267                 int ret;
 268
 269                 ret = print_spool_write(fsp, data, n, pos, &t);
 270                 if (ret) {
 271                         errno = ret;
 272                         return -1;
 273                 }
 274                 return t;
 275         }
 276
 277         if (!fsp->fsp_flags.can_write) {
 278                 errno = EPERM;
 279                 return -1;
 280         }
 281
 282         mark_file_modified(fsp);
 283
 284         /*
 285          * If this file is level II oplocked then we need
 286          * to grab the shared memory lock and inform all
 287          * other files with a level II lock that they need
 288          * to flush their read caches. We keep the lock over
 289          * the shared memory area whilst doing this.
 290          */
 291
 292         /* This should actually be improved to span the write. */
 293         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WRITE);
 294         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WRITE);
 295
 296         total_written = real_write_file(req, fsp, data, pos, n);
 297         return total_written;
 298 }
 299
 300 /*******************************************************************
 301 sync a file
 302 ********************************************************************/
 303
 304 NTSTATUS sync_file(connection_struct *conn, files_struct *fsp, bool write_through)
 305 {
 306         if (fsp->fh->fd == -1)
 307                 return NT_STATUS_INVALID_HANDLE;
 308
 309         if (lp_strict_sync(SNUM(conn)) &&
 310             (lp_sync_always(SNUM(conn)) || write_through)) {
 311                 int ret;
 312                 ret = smb_vfs_fsync_sync(fsp);
 313                 if (ret == -1) {
 314                         return map_nt_error_from_unix(errno);
 315                 }
 316         }
 317         return NT_STATUS_OK;
 318 }