Changeset 427 for vendor/current/source3/smbd

Timestamp:

Apr 9, 2010, 3:20:58 PM (15 years ago)

Author:

Silvan Scherrer

Message:

Samba 3.5.x: update to 3.5.2

Location:

vendor/current/source3/smbd

Files:

• blocking.c (modified) (2 diffs)
• posix_acls.c (modified) (1 diff)
• process.c (modified) (2 diffs)
• reply.c (modified) (2 diffs)
• server.c (modified) (3 diffs)
• service.c (modified) (1 diff)
• sesssetup.c (modified) (1 diff)

vendor/current/source3/smbd/blocking.c

@@ -73 +73 @@
         struct blocking_lock_record *blr;
         struct timeval next_timeout;
+        int max_brl_timeout = lp_parm_int(-1, "brl", "recalctime", 5);
 
         TALLOC_FREE(brl_timeout);
@@ -99 +100 @@
                 DEBUG(10, ("Next timeout = Infinite.\n"));
                 return True;
+        }
+
+        /* 
+         to account for unclean shutdowns by clients we need a
+         maximum timeout that we use for checking pending locks. If
+         we have any pending locks at all, then check if the pending
+         lock can continue at least every brl:recalctime seconds
+         (default 5 seconds).
+
+         This saves us needing to do a message_send_all() in the
+         SIGCHLD handler in the parent daemon. That
+         message_send_all() caused O(n^2) work to be done when IP
+         failovers happened in clustered Samba, which could make the
+         entire system unusable for many minutes.
+        */
+
+        if (max_brl_timeout > 0) {
+                struct timeval min_to = timeval_current_ofs(max_brl_timeout, 0);
+                next_timeout = timeval_min(&next_timeout, &min_to);             
         }
 

vendor/current/source3/smbd/posix_acls.c

@@ -2699 +2699 @@
 
         /* Use the psbuf that was passed in. */
-        fsp->fsp_name->st = *psbuf;
+        if (psbuf != &fsp->fsp_name->st) {
+                fsp->fsp_name->st = *psbuf;
+        }
 
 #if defined(POSIX_ACL_NEEDS_MASK)

vendor/current/source3/smbd/process.c

@@ -1813 +1813 @@
 
         if ((req->wct < 2) || (CVAL(req->outbuf, smb_wct) < 2)) {
+                if (req->chain_outbuf == NULL) {
+                        req->chain_outbuf = TALLOC_REALLOC_ARRAY(
+                                req, req->outbuf, uint8_t,
+                                smb_len(req->outbuf) + 4);
+                        if (req->chain_outbuf == NULL) {
+                                smb_panic("talloc failed");
+                        }
+                }
+                req->outbuf = NULL;
                 goto error;
         }
@@ -1840 +1849 @@
                         req, req->outbuf, uint8_t, smb_len(req->outbuf) + 4);
                 if (req->chain_outbuf == NULL) {
-                        goto error;
+                        smb_panic("talloc failed");
                 }
                 req->outbuf = NULL;

vendor/current/source3/smbd/reply.c

@@ -2397 +2397 @@
                 ret = SMB_VFS_LSTAT(conn, smb_fname);
         } else {
-                ret = SMB_VFS_LSTAT(conn, smb_fname);
+                ret = SMB_VFS_STAT(conn, smb_fname);
         }
         if (ret != 0) {
@@ -5847 +5847 @@
                           smb_fname_str_dbg(smb_fname_dst)));
 
+                if (lp_map_archive(SNUM(conn)) ||
+                    lp_store_dos_attributes(SNUM(conn))) {
+                        /* We must set the archive bit on the newly
+                           renamed file. */
+                        if (SMB_VFS_STAT(conn, smb_fname_dst) == 0) {
+                                uint32_t old_dosmode = dos_mode(conn,
+                                                        smb_fname_dst);
+                                file_set_dosmode(conn,
+                                        smb_fname_dst,
+                                        old_dosmode | FILE_ATTRIBUTE_ARCHIVE,
+                                        NULL,
+                                        true);
+                        }
+                }
+
                 notify_rename(conn, fsp->is_directory, fsp->fsp_name,
                               smb_fname_dst);

vendor/current/source3/smbd/server.c

@@ -220 +220 @@
 }
 
+/*
+  at most every smbd:cleanuptime seconds (default 20), we scan the BRL
+  and locking database for entries to cleanup. As a side effect this
+  also cleans up dead entries in the connections database (due to the
+  traversal in message_send_all()
+
+  Using a timer for this prevents a flood of traversals when a large
+  number of clients disconnect at the same time (perhaps due to a
+  network outage).  
+*/
+
+static void cleanup_timeout_fn(struct event_context *event_ctx,
+                                struct timed_event *te,
+                                struct timeval now,
+                                void *private_data)
+{
+        struct timed_event **cleanup_te = (struct timed_event **)private_data;
+
+        DEBUG(1,("Cleaning up brl and lock database after unclean shutdown\n"));
+        message_send_all(smbd_messaging_context(), MSG_SMB_UNLOCK, NULL, 0, NULL);
+        messaging_send_buf(smbd_messaging_context(), procid_self(), 
+                                MSG_SMB_BRL_VALIDATE, NULL, 0);
+        /* mark the cleanup as having been done */
+        (*cleanup_te) = NULL;
+}
+
 static void remove_child_pid(pid_t pid, bool unclean_shutdown)
 {
         struct child_pid *child;
+        static struct timed_event *cleanup_te;
 
         if (unclean_shutdown) {
-                /* a child terminated uncleanly so tickle all processes to see 
-                   if they can grab any of the pending locks
-                */
-                DEBUG(3,(__location__ " Unclean shutdown of pid %u\n", (unsigned int)pid));
-                messaging_send_buf(smbd_messaging_context(), procid_self(), 
-                                   MSG_SMB_BRL_VALIDATE, NULL, 0);
-                message_send_all(smbd_messaging_context(), 
-                                 MSG_SMB_UNLOCK, NULL, 0, NULL);
+                /* a child terminated uncleanly so tickle all
+                   processes to see if they can grab any of the
+                   pending locks
+                */
+                DEBUG(3,(__location__ " Unclean shutdown of pid %u\n", 
+                        (unsigned int)pid));
+                if (!cleanup_te) {
+                        /* call the cleanup timer, but not too often */
+                        int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
+                        cleanup_te = event_add_timed(smbd_event_context(), NULL,
+                                                timeval_current_ofs(cleanup_time, 0),
+                                                cleanup_timeout_fn, 
+                                                &cleanup_te);
+                        DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
+                }
         }
 
@@ -1048 +1082 @@
         gain_root_group_privilege();
 
-        /*
-         * Ensure we have CAP_KILL capability set on Linux,
-         * where we need this to communicate with threads.
-         * This is inherited by new threads, but not by new
-         * processes across exec().
-         */
-        set_effective_capability(KILL_CAPABILITY);
-
         fault_setup((void (*)(void *))exit_server_fault);
         dump_core_setup("smbd");
@@ -1281 +1307 @@
 
         TALLOC_FREE(frame);
+        /* make sure we always have a valid stackframe */
+        frame = talloc_stackframe();
 
         smbd_parent_loop(parent);
 
         exit_server_cleanly(NULL);
+        TALLOC_FREE(frame);
         return(0);
 }

vendor/current/source3/smbd/service.c

@@ -340 +340 @@
                         iPrinterService = load_registry_service(PRINTERS_NAME);
                 }
-                if (iPrinterService) {
+                if (iPrinterService >= 0) {
                         DEBUG(3,("checking whether %s is a valid printer name...\n", service));
                         if (pcap_printername_ok(service)) {

vendor/current/source3/smbd/sesssetup.c

@@ -1214 +1214 @@
 #endif
 
-        p2 = (char *)req->buf + data_blob_len;
+        p2 = (char *)req->buf + blob1.length;
 
         p2 += srvstr_pull_req_talloc(talloc_tos(), req, &tmp, p2,