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
  36         /* you can't read from print files */
  37         if (fsp->print_file) {
  38                 errno = EBADF;
  39                 return -1;
  40         }
  41
  42         fsp->fh->pos = pos;
  43
  44         if (n > 0) {
  45                 ret = SMB_VFS_PREAD(fsp,data,n,pos);
  46
  47                 if (ret == -1) {
  48                         return -1;
  49                 }
  50         }
  51
  52         DEBUG(10,("read_file (%s): pos = %.0f, size = %lu, returned %lu\n",
  53                   fsp_str_dbg(fsp), (double)pos, (unsigned long)n, (long)ret));
  54
  55         fsp->fh->pos += ret;
  56         fsp->fh->position_information = fsp->fh->pos;
  57
  58         return(ret);
  59 }
  60
  61 /****************************************************************************
  62  *Really* write to a file.
  63 ****************************************************************************/
  64
  65 static ssize_t real_write_file(struct smb_request *req,
  66                                 files_struct *fsp,
  67                                 const char *data,
  68                                 off_t pos,
  69                                 size_t n)
  70 {
  71         ssize_t ret;
  72
  73         fsp->fh->pos = pos;
  74         if (pos && lp_strict_allocate(SNUM(fsp->conn) &&
  75                         !fsp->is_sparse)) {
  76                 if (vfs_fill_sparse(fsp, pos) == -1) {
  77                         return -1;
  78                 }
  79         }
  80         ret = vfs_pwrite_data(req, fsp, data, n, pos);
  81
  82         DEBUG(10,("real_write_file (%s): pos = %.0f, size = %lu, returned %ld\n",
  83                   fsp_str_dbg(fsp), (double)pos, (unsigned long)n, (long)ret));
  84
  85         if (ret != -1) {
  86                 fsp->fh->pos += ret;
  87
  88 /* Yes - this is correct - writes don't update this. JRA. */
  89 /* Found by Samba4 tests. */
  90 #if 0
  91                 fsp->position_information = fsp->pos;
  92 #endif
  93         }
  94
  95         return ret;
  96 }
  97
  98 void fsp_flush_write_time_update(struct files_struct *fsp)
  99 {
 100         /*
 101          * Note this won't expect any impersonation!
 102          * So don't call any SMB_VFS operations here!
 103          */
 104
 105         DEBUG(5, ("Update write time on %s\n", fsp_str_dbg(fsp)));
 106
 107         /* change the write time in the open file db. */
 108         (void)set_write_time(fsp->file_id, timespec_current());
 109
 110         /* And notify. */
 111         notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
 112                      FILE_NOTIFY_CHANGE_LAST_WRITE, fsp->fsp_name->base_name);
 113
 114         /* Remove the timed event handler. */
 115         TALLOC_FREE(fsp->update_write_time_event);
 116 }
 117
 118 static void update_write_time_handler(struct tevent_context *ctx,
 119                                       struct tevent_timer *te,
 120                                       struct timeval now,
 121                                       void *private_data)
 122 {
 123         files_struct *fsp = (files_struct *)private_data;
 124         fsp_flush_write_time_update(fsp);
 125 }
 126
 127 /*********************************************************
 128  Schedule a write time update for WRITE_TIME_UPDATE_USEC_DELAY
 129  in the future.
 130 *********************************************************/
 131
 132 void trigger_write_time_update(struct files_struct *fsp)
 133 {
 134         int delay;
 135
 136         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 137                 /* Don't use delayed writes on POSIX files. */
 138                 return;
 139         }
 140
 141         if (fsp->write_time_forced) {
 142                 /* No point - "sticky" write times
 143                  * in effect.
 144                  */
 145                 return;
 146         }
 147
 148         /* We need to remember someone did a write
 149          * and update to current time on close. */
 150
 151         fsp->update_write_time_on_close = true;
 152
 153         if (fsp->update_write_time_triggered) {
 154                 /*
 155                  * We only update the write time after 2 seconds
 156                  * on the first normal write. After that
 157                  * no other writes affect this until close.
 158                  */
 159                 return;
 160         }
 161         fsp->update_write_time_triggered = true;
 162
 163         delay = lp_parm_int(SNUM(fsp->conn),
 164                             "smbd", "writetimeupdatedelay",
 165                             WRITE_TIME_UPDATE_USEC_DELAY);
 166
 167         DEBUG(5, ("Update write time %d usec later on %s\n",
 168                   delay, fsp_str_dbg(fsp)));
 169
 170         /* trigger the update 2 seconds later */
 171         fsp->update_write_time_event =
 172                 tevent_add_timer(fsp->conn->sconn->ev_ctx, NULL,
 173                                  timeval_current_ofs_usec(delay),
 174                                  update_write_time_handler, fsp);
 175 }
 176
 177 void trigger_write_time_update_immediate(struct files_struct *fsp)
 178 {
 179         struct smb_file_time ft;
 180
 181         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 182                 /* Don't use delayed writes on POSIX files. */
 183                 return;
 184         }
 185
 186         if (fsp->write_time_forced) {
 187                 /*
 188                  * No point - "sticky" write times
 189                  * in effect.
 190                  */
 191                 return;
 192         }
 193
 194         TALLOC_FREE(fsp->update_write_time_event);
 195         DEBUG(5, ("Update write time immediate on %s\n",
 196                   fsp_str_dbg(fsp)));
 197
 198         /* After an immediate update, reset the trigger. */
 199         fsp->update_write_time_triggered = true;
 200         fsp->update_write_time_on_close = false;
 201
 202         ft = (struct smb_file_time) { .mtime = timespec_current() };
 203
 204         /* Update the time in the open file db. */
 205         (void)set_write_time(fsp->file_id, ft.mtime);
 206
 207         /* Now set on disk - takes care of notify. */
 208         (void)smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
 209 }
 210
 211 void mark_file_modified(files_struct *fsp)
 212 {
 213         int dosmode;
 214
 215         if (fsp->modified) {
 216                 return;
 217         }
 218
 219         fsp->modified = true;
 220
 221         if (SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
 222                 return;
 223         }
 224         trigger_write_time_update(fsp);
 225
 226         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 227                 return;
 228         }
 229         if (!(lp_store_dos_attributes(SNUM(fsp->conn)) ||
 230               MAP_ARCHIVE(fsp->conn))) {
 231                 return;
 232         }
 233
 234         dosmode = dos_mode(fsp->conn, fsp->fsp_name);
 235         if (IS_DOS_ARCHIVE(dosmode)) {
 236                 return;
 237         }
 238         file_set_dosmode(fsp->conn, fsp->fsp_name,
 239                          dosmode | FILE_ATTRIBUTE_ARCHIVE, NULL, false);
 240 }
 241
 242 /****************************************************************************
 243  Write to a file.
 244 ****************************************************************************/
 245
 246 ssize_t write_file(struct smb_request *req,
 247                         files_struct *fsp,
 248                         const char *data,
 249                         off_t pos,
 250                         size_t n)
 251 {
 252         ssize_t total_written = 0;
 253
 254         if (fsp->print_file) {
 255                 uint32_t t;
 256                 int ret;
 257
 258                 ret = print_spool_write(fsp, data, n, pos, &t);
 259                 if (ret) {
 260                         errno = ret;
 261                         return -1;
 262                 }
 263                 return t;
 264         }
 265
 266         if (!fsp->can_write) {
 267                 errno = EPERM;
 268                 return -1;
 269         }
 270
 271         mark_file_modified(fsp);
 272
 273         /*
 274          * If this file is level II oplocked then we need
 275          * to grab the shared memory lock and inform all
 276          * other files with a level II lock that they need
 277          * to flush their read caches. We keep the lock over
 278          * the shared memory area whilst doing this.
 279          */
 280
 281         /* This should actually be improved to span the write. */
 282         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WRITE);
 283         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WRITE);
 284
 285         total_written = real_write_file(req, fsp, data, pos, n);
 286         return total_written;
 287 }
 288
 289 /*******************************************************************
 290 sync a file
 291 ********************************************************************/
 292
 293 NTSTATUS sync_file(connection_struct *conn, files_struct *fsp, bool write_through)
 294 {
 295         if (fsp->fh->fd == -1)
 296                 return NT_STATUS_INVALID_HANDLE;
 297
 298         if (lp_strict_sync(SNUM(conn)) &&
 299             (lp_sync_always(SNUM(conn)) || write_through)) {
 300                 int ret;
 301                 ret = smb_vfs_fsync_sync(fsp);
 302                 if (ret == -1) {
 303                         return map_nt_error_from_unix(errno);
 304                 }
 305         }
 306         return NT_STATUS_OK;
 307 }