update

Author: jaredmauch

Mailman/Handlers/Decorate.py

@@ -201,19 +201,31 @@ def process(mlist, msg, msgdata):
     msg['Content-Type'] = 'multipart/mixed'
 
 
-
 def decorate(mlist, template, what, extradict=None):
     # `what' is just a descriptive phrase used in the log message
 
     # If template is None, return empty string
     if template is None:
+        syslog('error', 'Template is None for %s', what)
         return ''
 
     # If template is a Message object, get its content
     if isinstance(template, Message):
-        template = template.get_payload(decode=True)
-        if isinstance(template, bytes):
-            template = template.decode('utf-8', 'replace')
+        try:
+            template = template.get_payload(decode=True)
+            if isinstance(template, bytes):
+                template = template.decode('utf-8', 'replace')
+        except Exception as e:
+            syslog('error', 'Error getting payload from Message template for %s: %s', what, str(e))
+            return ''
+    
+    # Ensure template is a string
+    if not isinstance(template, str):
+        try:
+            template = str(template)
+        except Exception as e:
+            syslog('error', 'Error converting template to string for %s: %s', what, str(e))
+            return ''
 
     # If template is only whitespace, ignore it.
     if len(re.sub(r'\s', '', template)) == 0:

Mailman/Queue/Runner.py

@@ -186,10 +186,6 @@ def _oneloop(self):
             files = self._switchboard.files()
             filecnt = len(files)
 
-            # Only log at debug level if we found files to process
-            if filecnt > 0:
-                syslog('debug', 'Runner._oneloop: Found %d files to process', filecnt)
-            
             # Process each file
             for filebase in files:
                 try:
@@ -198,41 +194,22 @@ def _oneloop(self):
                     if msg is None:
                         continue
 
-                    syslog('info', 'Runner._oneloop: Successfully dequeued file %s', filebase)
-                    
                     # Process the message
                     try:
-                        # Get the list name from the message data
-                        listname = msgdata.get('listname', mm_cfg.MAILMAN_SITE_LIST)
-                        
-                        # Process the message
-                        result = self._dispose(listname, msg, msgdata)
-                        
-                        # If the message should be kept in the queue, requeue it
-                        if result:
-                            self._switchboard.enqueue(msg, msgdata)
-                            syslog('info', 'Runner._oneloop: Message requeued for later processing: %s', filebase)
-                        else:
-                            syslog('info', 'Runner._oneloop: Message processing complete, moving to shunt queue %s (msgid: %s)',
-                                  filebase, msg.get('message-id', 'n/a'))
-                            
+                        self._dopost(msg, msgdata)
                     except Exception as e:
-                        syslog('error', 'Runner._oneloop: Error processing message: %s\n%s',
-                              str(e), traceback.format_exc())
-                        # Move to shunt queue on error
-                        self._shunt.enqueue(msg, msgdata)
+                        syslog('error', 'Runner._oneloop: Error processing message %s: %s', filebase, str(e))
+                        continue
 
                 except Exception as e:
-                    syslog('error', 'Runner._oneloop: Error dequeuing file %s: %s\n%s',
-                          filebase, str(e), traceback.format_exc())
+                    syslog('error', 'Runner._oneloop: Error dequeuing file %s: %s', filebase, str(e))
+                    continue
 
-            # Only log completion at debug level if we processed files
-            if filecnt > 0:
-                syslog('debug', 'Runner._oneloop: Loop complete, processed %d files', filecnt)
-                
         except Exception as e:
-            syslog('error', 'Runner._oneloop: Unexpected error in main loop: %s\n%s',
-                  str(e), traceback.format_exc())
+            syslog('error', 'Runner._oneloop: Error in main loop: %s', str(e))
+            return 0
+            
+        return filecnt
 
     def _validate_message(self, msg, msgdata):
         """Validate and convert message if needed.

Mailman/Queue/Switchboard.py

@@ -114,81 +114,67 @@ def enqueue(self, msg, msgdata=None, listname=None, _plaintext=False, **kwargs):
         # Store any additional keyword arguments in msgdata
         msgdata.update(kwargs)
 
-        mailman_log('debug', 'Switchboard.enqueue: Starting to enqueue message for list %s', listname or 'unknown')
-        
         # Convert string message to Message object if needed
         if isinstance(msg, str):
             try:
                 msg = email.message_from_string(msg)
-                mailman_log('debug', 'Switchboard.enqueue: Converted string message to Message object')
             except Exception as e:
                 mailman_log('error', 'Switchboard.enqueue: Failed to convert string message to Message object: %s', str(e))
                 raise
 
         # Generate a unique filebase
         filebase = self._make_filebase(msg, msgdata)
-        mailman_log('debug', 'Switchboard.enqueue: Generated filebase %s', filebase)
 
         # Calculate the filename
         filename = os.path.join(self.__whichq, filebase + '.pck')
-        mailman_log('debug', 'Switchboard.enqueue: Target filename is %s', filename)
 
         # Create a lock file
         lockfile = filename + '.lock'
         try:
             fd = os.open(lockfile, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
             os.close(fd)
-            mailman_log('debug', 'Switchboard.enqueue: Created lock file for %s', filebase)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 mailman_log('error', 'Switchboard.enqueue: Failed to create lock file for %s: %s', filebase, str(e))
                 raise
-            mailman_log('debug', 'Switchboard.enqueue: Lock file already exists for %s', filebase)
             return None
 
         try:
             # Write the message and metadata
             try:
                 self._enqueue(filename, msg, msgdata, _plaintext)
-                mailman_log('debug', 'Switchboard.enqueue: Successfully wrote message and data to %s', filebase)
             except Exception as e:
                 mailman_log('error', 'Switchboard.enqueue: Failed to write message to %s: %s', filebase, str(e))
                 raise
 
-            mailman_log('debug', 'Switchboard.enqueue: Successfully enqueued message to %s', filebase)
             return filebase
         finally:
             # Always clean up the lock file
             try:
                 os.unlink(lockfile)
-                mailman_log('debug', 'Switchboard.enqueue: Cleaned up lock file %s', lockfile)
             except OSError:
                 pass
 
     def dequeue(self, filebase):
         # Calculate the filename from the given filebase.
         filename = os.path.join(self.__whichq, filebase + '.pck')
-        mailman_log('debug', 'Switchboard.dequeue: Attempting to dequeue file %s', filebase)
 
         # Create a lock file
         lockfile = filename + '.lock'
         try:
             # Try to create the lock file
             fd = os.open(lockfile, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
             os.close(fd)
-            mailman_log('debug', 'Switchboard.dequeue: Created lock file for %s', filebase)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 mailman_log('error', 'Switchboard.dequeue: Failed to create lock file for %s: %s', filebase, str(e))
                 raise
-            mailman_log('debug', 'Switchboard.dequeue: Lock file already exists for %s', filebase)
             return None, None
 
         try:
             # Read the message and metadata
             try:
                 msg, data = self._dequeue(filename)
-                mailman_log('debug', 'Switchboard.dequeue: Successfully read message and data from %s', filebase)
             except Exception as e:
                 mailman_log('error', 'Switchboard.dequeue: Failed to read message from %s: %s', filebase, str(e))
                 raise
@@ -198,13 +184,11 @@ def dequeue(self, filebase):
                 mailman_log('error', 'Switchboard.dequeue: Invalid data structure in %s: expected dict, got %s', filename, type(data))
                 return None, None
 
-            mailman_log('debug', 'Switchboard.dequeue: Successfully dequeued file %s', filebase)
             return msg, data
         finally:
             # Always clean up the lock file
             try:
                 os.unlink(lockfile)
-                mailman_log('debug', 'Switchboard.dequeue: Cleaned up lock file %s', lockfile)
             except OSError:
                 pass
 

bin/mailmanctl

@@ -103,6 +103,7 @@ import errno
 import pwd
 import grp
 import socket
+import psutil  # Add psutil import
 
 import paths
 from Mailman import mm_cfg
@@ -210,19 +211,53 @@ def get_lock_data():
 
 
 def qrunner_state():
-    # 1 if proc exists on host (but is it qrunner? ;)
-    # 0 if host matches but no proc
+    # 1 if proc exists on host and is owned by mailman user
+    # 0 if host matches but no proc or wrong owner
     # hostname if hostname doesn't match
     hostname, pid, tempfile = get_lock_data()
     if hostname != socket.gethostname():
         return hostname
     # Find out if the process exists by calling kill with a signal 0.
     try:
         os.kill(pid, 0)
+        # Process exists, now check if it's owned by the mailman user
+        mailman_uid = pwd.getpwnam(mm_cfg.MAILMAN_USER).pw_uid
+        try:
+            # Try to get process owner using platform-specific methods
+            if os.name == 'posix':
+                # On Unix-like systems, try to get process owner
+                try:
+                    # Try using /proc on Linux
+                    if os.path.exists('/proc'):
+                        with open(f'/proc/{pid}/status') as f:
+                            for line in f:
+                                if line.startswith('Uid:'):
+                                    uid = int(line.split()[1])
+                                    if uid != mailman_uid:
+                                        syslog('error', 'Process %d exists but is owned by uid %d, not mailman user %d',
+                                               pid, uid, mailman_uid)
+                                        return 0
+                                    break
+                    else:
+                        # On other Unix systems, we can't easily check the owner
+                        # without external tools, so we'll assume it's valid
+                        # if the process exists
+                        return 1
+                except (IOError, OSError) as e:
+                    syslog('error', 'Error checking process %d ownership: %s', pid, str(e))
+                    return 0
+            else:
+                # On non-Unix systems, we can't easily check the owner
+                # without external tools, so we'll assume it's valid
+                # if the process exists
+                return 1
+            return 1
+        except Exception as e:
+            syslog('error', 'Error checking process %d ownership: %s', pid, str(e))
+            return 0
     except OSError as e:
         if e.errno != errno.ESRCH: raise
         return 0
-    return 1
 
 
 def acquire_lock_1(force):
@@ -233,10 +268,12 @@ def acquire_lock_1(force):
         lock.lock(0.1)
         return lock
     except LockFile.TimeOutError:
-        # If we're not forcing or the lock can't be determined to be stale.
-        if not force or qrunner_state():
+        # Check if the lock is stale by examining the process
+        status = qrunner_state()
+        if status == 1:
+            # Process exists and is running, so lock is valid
             raise
-        # Force removal of lock first
+        # Lock appears to be stale - clean it up
         try:
             # Read the current lock file content
             with open(LOCKFILE) as fp: