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         init_smb_file_time(&ft);
 182
 183         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 184                 /* Don't use delayed writes on POSIX files. */
 185                 return;
 186         }
 187
 188         if (fsp->write_time_forced) {
 189                 /*
 190                  * No point - "sticky" write times
 191                  * in effect.
 192                  */
 193                 return;
 194         }
 195
 196         TALLOC_FREE(fsp->update_write_time_event);
 197         DEBUG(5, ("Update write time immediate on %s\n",
 198                   fsp_str_dbg(fsp)));
 199
 200         /* After an immediate update, reset the trigger. */
 201         fsp->update_write_time_triggered = true;
 202         fsp->update_write_time_on_close = false;
 203
 204         ft.mtime = timespec_current();
 205
 206         /* Update the time in the open file db. */
 207         (void)set_write_time(fsp->file_id, ft.mtime);
 208
 209         /* Now set on disk - takes care of notify. */
 210         (void)smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
 211 }
 212
 213 void mark_file_modified(files_struct *fsp)
 214 {
 215         int dosmode;
 216
 217         trigger_write_time_update(fsp);
 218
 219         if (fsp->modified) {
 220                 return;
 221         }
 222
 223         fsp->modified = true;
 224
 225         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
 226                 return;
 227         }
 228         if (!(lp_store_dos_attributes(SNUM(fsp->conn)) ||
 229               MAP_ARCHIVE(fsp->conn))) {
 230                 return;
 231         }
 232
 233         dosmode = dos_mode(fsp->conn, fsp->fsp_name);
 234         if (IS_DOS_ARCHIVE(dosmode)) {
 235                 return;
 236         }
 237         file_set_dosmode(fsp->conn, fsp->fsp_name,
 238                          dosmode | FILE_ATTRIBUTE_ARCHIVE, NULL, false);
 239 }
 240
 241 /****************************************************************************
 242  Write to a file.
 243 ****************************************************************************/
 244
 245 ssize_t write_file(struct smb_request *req,
 246                         files_struct *fsp,
 247                         const char *data,
 248                         off_t pos,
 249                         size_t n)
 250 {
 251         ssize_t total_written = 0;
 252
 253         if (fsp->print_file) {
 254                 uint32_t t;
 255                 int ret;
 256
 257                 ret = print_spool_write(fsp, data, n, pos, &t);
 258                 if (ret) {
 259                         errno = ret;
 260                         return -1;
 261                 }
 262                 return t;
 263         }
 264
 265         if (!fsp->can_write) {
 266                 errno = EPERM;
 267                 return -1;
 268         }
 269
 270         mark_file_modified(fsp);
 271
 272         /*
 273          * If this file is level II oplocked then we need
 274          * to grab the shared memory lock and inform all
 275          * other files with a level II lock that they need
 276          * to flush their read caches. We keep the lock over
 277          * the shared memory area whilst doing this.
 278          */
 279
 280         /* This should actually be improved to span the write. */
 281         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WRITE);
 282         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WRITE);
 283
 284         total_written = real_write_file(req, fsp, data, pos, n);
 285         return total_written;
 286 }
 287
 288 /*******************************************************************
 289 sync a file
 290 ********************************************************************/
 291
 292 NTSTATUS sync_file(connection_struct *conn, files_struct *fsp, bool write_through)
 293 {
 294         if (fsp->fh->fd == -1)
 295                 return NT_STATUS_INVALID_HANDLE;
 296
 297         if (lp_strict_sync(SNUM(conn)) &&
 298             (lp_sync_always(SNUM(conn)) || write_through)) {
 299                 int ret;
 300                 ret = smb_vfs_fsync_sync(fsp);
 301                 if (ret == -1) {
 302                         return map_nt_error_from_unix(errno);
 303                 }
 304         }
 305         return NT_STATUS_OK;
 306 }