Collective guilt for registrants from the same IP address

If someone tries to register from an IP address that a silenced user
has registered from, prevent it.

When silencing someone, silence everyone else who registered from the
same IP address.

plugins/RegisterThrottle/RegisterThrottlePlugin.php

@@ -57,6 +57,19 @@ class RegisterThrottlePlugin extends Plugin
                               86400 => 5, // per day
                               3600 => 3); // per hour
 
+    /**
+     * Disallow registration if a silenced user has registered from
+     * this IP address.
+     */
+
+    public $silenced = true;
+
+    /**
+     * Whether we're enabled; prevents recursion.
+     */
+
+    static private $enabled = true;
+
     /**
      * Database schema setup
      *
@@ -138,6 +151,18 @@ class RegisterThrottlePlugin extends Plugin
             }
         }
 
+        // Check for silenced users
+
+        if ($this->silenced) {
+            $ids = Registration_ip::usersByIP($ipaddress);
+            foreach ($ids as $id) {
+                $profile = Profile::staticGet('id', $id);
+                if ($profile->isSilenced()) {
+                    throw new Exception(_("A banned user has registered from this address."));
+                }
+            }
+        }
+
         return true;
     }
 
@@ -245,4 +270,59 @@ class RegisterThrottlePlugin extends Plugin
             return null;
         }
     }
+
+    /**
+     * When silencing a user, silence all other users registered from that IP
+     * address.
+     *
+     * @param Profile $profile Person getting a new role
+     * @param string  $role    Role being assigned like 'moderator' or 'silenced'
+     *
+     * @return boolean hook value
+     */
+
+    function onEndGrantRole($profile, $role)
+    {
+        if (!self::$enabled) {
+            return true;
+        }
+
+        if ($role != Profile_role::SILENCED) {
+            return true;
+        }
+
+        if (!$this->silenced) {
+            return true;
+        }
+
+        $ri = Registration_ip::staticGet('user_id', $profile->id);
+
+        if (empty($ri)) {
+            return true;
+        }
+
+        $ids = Registration_ip::usersByIP($ri->ipaddress);
+
+        foreach ($ids as $id) {
+
+            if ($id == $profile->id) {
+                continue;
+            }
+
+            $other = Profile::staticGet('id', $id);
+
+            if (empty($other)) {
+                continue;
+            }
+
+            if ($other->isSilenced()) {
+                continue;
+            }
+
+            $old = self::$enabled;
+            self::$enabled = false;
+            $other->silence();
+            self::$enabled = $old;
+        }
+    }
 }

plugins/RegisterThrottle/Registration_ip.php

@@ -111,8 +111,33 @@ class Registration_ip extends Memcached_DataObject
      *
      * @return array magic three-false array that stops auto-incrementing.
      */
+
     function sequenceKey()
     {
         return array(false, false, false);
     }
+
+    /**
+     * Get the users who've registered with this ip address.
+     *
+     * @param Array $ipaddress IP address to check for
+     *
+     * @return Array IDs of users who registered with this address.
+     */
+
+    static function usersByIP($ipaddress)
+    {
+        $ids = array();
+
+        $ri            = new Registration_ip();
+        $ri->ipaddress = $ipaddress;
+
+        if ($ri->find()) {
+            while ($ri->fetch()) {
+                $ids[] = $ri->user_id;
+            }
+        }
+
+        return $ids;
+    }
 }