Changeset 745 for trunk/server/source3/smbd/fileio.c

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/smbd/fileio.c (modified) (6 diffs)

trunk/server/source3/smbd/fileio.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "printing.h"
+#include "smbd/smbd.h"
 #include "smbd/globals.h"
+#include "smbprofile.h"
 
 static bool setup_write_cache(files_struct *, SMB_OFF_T);
@@ -128 +131 @@
         } else {
                 fsp->fh->pos = pos;
-                if (pos && lp_strict_allocate(SNUM(fsp->conn))) {
+                if (pos && lp_strict_allocate(SNUM(fsp->conn) &&
+                                !fsp->is_sparse)) {
                         if (vfs_fill_sparse(fsp, pos) == -1) {
                                 return -1;
@@ -292 +296 @@
 
         if (fsp->print_file) {
-                uint32 jobid;
-
-                if (!rap_to_pjobid(fsp->rap_print_jobid, NULL, &jobid)) {
-                        DEBUG(3,("write_file: Unable to map RAP jobid %u to jobid.\n",
-                                                (unsigned int)fsp->rap_print_jobid ));
-                        errno = EBADF;
+                uint32_t t;
+                int ret;
+
+                ret = print_spool_write(fsp, data, n, pos, &t);
+                if (ret) {
+                        errno = ret;
                         return -1;
                 }
-
-                return print_job_write(SNUM(fsp->conn), jobid, data, pos, n);
+                return t;
         }
 
@@ -320 +323 @@
                                 if (!IS_DOS_ARCHIVE(dosmode)) {
                                         file_set_dosmode(fsp->conn, fsp->fsp_name,
-                                                 dosmode | aARCH, NULL, false);
+                                                 dosmode | FILE_ATTRIBUTE_ARCHIVE, NULL, false);
                                 }
                         }
@@ -403 +406 @@
         fsp->fh->pos = pos + n;
 
+        if ((n == 1) && (data[0] == '\0') && (pos > wcp->file_size)) {
+                int ret;
+
+                /*
+                 * This is a 1-byte write of a 0 beyond the EOF and
+                 * thus implicitly also beyond the current active
+                 * write cache, the typical file-extending (and
+                 * allocating, but we're using the write cache here)
+                 * write done by Windows. We just have to ftruncate
+                 * the file and rely on posix semantics to return
+                 * zeros for non-written file data that is within the
+                 * file length.
+                 *
+                 * We can not use wcp_file_size_change here because we
+                 * might have an existing write cache, and
+                 * wcp_file_size_change assumes a change to just the
+                 * end of the current write cache.
+                 */
+
+                wcp->file_size = pos + 1;
+                ret = SMB_VFS_FTRUNCATE(fsp, wcp->file_size);
+                if (ret == -1) {
+                        DEBUG(0,("wcp_file_size_change (%s): ftruncate of size %.0f"
+                                 "error %s\n", fsp_str_dbg(fsp),
+                                 (double)wcp->file_size, strerror(errno)));
+                        return -1;
+                }
+                return 1;
+        }
+
+
         /*
          * If we have active cache and it isn't contiguous then we flush.
@@ -794 +828 @@
                 }
 #endif
+
+                if ((wcp->data_size == 0)
+                    && (pos > wcp->file_size)
+                    && (pos + n <= wcp->file_size + wcp->alloc_size)) {
+                        /*
+                         * This is a write completely beyond the
+                         * current EOF, but within reach of the write
+                         * cache. We expect fill-up writes pretty
+                         * soon, so it does not make sense to start
+                         * the write cache at the current
+                         * offset. These fill-up writes would trigger
+                         * separate pwrites or even unnecessary cache
+                         * flushes because they overlap if this is a
+                         * one-byte allocating write.
+                         */
+                        wcp->offset = wcp->file_size;
+                        wcp->data_size = pos - wcp->file_size;
+                        memset(wcp->data, 0, wcp->data_size);
+                }
+
                 memcpy(wcp->data+wcp->data_size, data, n);
                 if (wcp->data_size == 0) {