@@ -639,18 +639,22 @@ opensips-cli -x mi clusterer_controller:shtag_auto cluster_id=1
 
 #### clusterer_controller:maintenance
 
-Put THIS node in or out of maintenance, e.g. for a rolling upgrade. A node in maintenance (*evicted*) stays a member - it keeps its node_id, its BIN links and its place in *clusterer_controller:list_members* - but it is never master or backup and holds no sharing tag. If it is the master, it hands over at once: its last keepalive carries the new state, and every member elects the successor as soon as it reads it, without waiting for the master watchdog. A *clusterer_controller:shtag_force* pin is refused for a node in maintenance, and a pin already on a node that goes into maintenance is cleared (automatic allocation resumes). Only when every node in the election window is in maintenance does the cluster take one of them as master anyway - a cluster must have a master.
+Put this node - or, with *node_id*, any member - in or out of maintenance, e.g. for a rolling upgrade. A node in maintenance (*evicted* or *full*) stays a member - it keeps its node_id, its BIN links and its place in *clusterer_controller:list_members* - but it is never master or backup and holds no sharing tag. If it is the master, it hands over at once: its last keepalive carries the new state, and every member elects the successor as soon as it reads it, without waiting for the master watchdog. A *clusterer_controller:shtag_force* pin is refused for a node in maintenance, and a pin already on a node that goes into maintenance is cleared (automatic allocation resumes). Only when every node in the election window is in maintenance does the cluster take one of them as master anyway - a cluster must have a master.
 
-The state is announced by the node itself and relayed by the master, so every node agrees on it and it survives a master failover. It is runtime-only: a restart brings the node back in service.
+At *full*, every other node also disables it in its *clusterer* (as *clusterer:set_status* would), so they take their link to it down and stop sending it replication; leaving *full* enables it again and *clusterer* resumes pinging it. A node never disables itself - its peers do.
+
+The state is announced by the node itself and relayed by the master, so every node agrees on it and it survives a master failover. A request for another node is multicast to the cluster and that node applies it to itself, so it takes effect only while that node is reachable. The state is runtime-only: a restart brings the node back in service.
 
 Parameters:
 
 - *cluster_id* — the target cluster.
-- *state* — *evicted* (or *on*) to enter maintenance, *none* (or *off*) to leave it.
+- *state* — *evicted* (or *on*) or *full* to enter maintenance, *none* (or *off*) to leave it.
+- *node_id* (optional) — the member to act on; this node when omitted.
 
 ```bash title="clusterer_controller:maintenance usage"
 opensips-cli -x mi clusterer_controller:maintenance cluster_id=1 state=evicted
-opensips-cli -x mi clusterer_controller:maintenance cluster_id=1 state=none
+opensips-cli -x mi clusterer_controller:maintenance cluster_id=1 state=full node_id=3
+opensips-cli -x mi clusterer_controller:maintenance cluster_id=1 state=none node_id=3
 ```
 
 ### Exported Pseudo-Variables
@@ -659,7 +663,7 @@ These read-only pseudo-variables expose live cluster state to the routing script
 
 Each variable optionally takes a cluster id as its argument, e.g. *$cl_ctr_role(2)*. The bare form (*$cl_ctr_role*) resolves to the only configured cluster; when several clusters are defined the bare form returns NULL and logs a one-time warning, so the cluster must be named explicitly. An unknown cluster id, or a value that is not currently known (e.g. no master yet), returns NULL. All of them are read-only - assigning to them fails.
 
-- **$cl_ctr_role** — this node's role in the cluster: *master*, *backup*, *member*, or *joining* (still authenticating / before the first election).
+- **$cl_ctr_role** — this node's role in the cluster: *master*, *backup*, *maintenance* (see *clusterer_controller:maintenance*), *member*, or *joining* (still authenticating / before the first election).
 - **$cl_ctr_is_master** — 1 if this node is the cluster master, 0 otherwise. A fast path for the most common check.
 - **$cl_ctr_master_ip** — IP of the current master (NULL if none is elected yet).
 - **$cl_ctr_backup_ip** — IP of the current backup / standby master (NULL if none).
@@ -668,7 +672,7 @@ Each variable optionally takes a cluster id as its argument, e.g. *$cl_ctr_role(
 - **$cl_ctr_members** — number of live members currently in the cluster.
 - **$cl_ctr_shtag_mode** — *auto* (tags follow the elected master) or *forced* (an operator pinned them with *clusterer_controller:shtag_force*).
 - **$cl_ctr_forced_node** — the *node_id* the active sharing tag is pinned to (NULL when in *auto* mode).
-- **$cl_ctr_maintenance** — this node's maintenance state: *none* or *evicted* (see *clusterer_controller:maintenance*).
+- **$cl_ctr_maintenance** — this node's maintenance state: *none*, *evicted* or *full* (see *clusterer_controller:maintenance*).
 
 ```opensips title="Using $cl_ctr_* in the script"
 # single cluster: run a periodic job only on the master
@@ -695,7 +699,7 @@ Meaning of the parameters is as follows:
 
 
 - *cluster_id* (int) - the cluster;
-- *state* (string) - *evicted* (or *on*) to enter maintenance, *none* (or *off*) to leave it.
+- *state* (string) - *evicted* (or *on*) or *full* to enter maintenance, *none* (or *off*) to leave it.
 
 
 Returns *1* on success, *-1* if the state is not recognised, the cluster is unknown or the controller worker is not running yet.
@@ -769,7 +773,7 @@ if (!cl_ctr_node_present(1, $var(peer)))
 #### cl_ctr_get_node_role(cluster_id, node_id, role_var)
 
 
-Writes a node's role - *master*, *backup* or *member* - into a variable.
+Writes a node's role - *master*, *backup*, *maintenance* or *member* - into a variable.
 
 
 Meaning of the parameters is as follows:
@@ -794,6 +798,34 @@ if (cl_ctr_get_node_role(1, 3, $var(role)))
 ```
 
 
+#### cl_ctr_get_node_maint(cluster_id, node_id, maint_var)
+
+
+Writes a node's maintenance state - *none*, *evicted* or *full* - into a variable.
+
+
+Meaning of the parameters is as follows:
+
+
+- *cluster_id* (int) - the cluster;
+- *node_id* (int) - the node;
+- *maint_var* (var) - receives the state.
+
+
+Returns *1* on success, *-1* if the node is not a member.
+
+
+This function can be used from any route.
+
+
+```opensips title="cl_ctr_get_node_maint() usage"
+...
+if (cl_ctr_get_node_maint(1, 3, $var(m)) && $var(m) != "none")
+    xlog("node 3 is in maintenance ($var(m))\n");
+...
+```
+
+
 #### cl_ctr_get_node_ip(cluster_id, node_id, ip_var)
 
 
@@ -1244,11 +1276,6 @@ Within one wire version, builds are kept compatible in both directions, so they
 
 The following features are planned for future releases:
 
-- **Node maintenance, the rest of it** — the *evicted* level is implemented (*clusterer_controller:maintenance*, *cl_ctr_set_maintenance()*, *$cl_ctr_maintenance*, *E_CL_CTR_MAINTENANCE*). Still planned:
-
-  - a *full* level that additionally marks the node down for clusterer consumers, so peers stop routing replication work to it (needs a clusterer hook to set a node's state);
-  - setting another node's state from any node (today a node sets its own);
-  - *$cl_ctr_node_maint(cluster_id, node_id)* for any peer, and a *maintenance* value of *$cl_ctr_role*.
 - **Statistics** — module statistics (current role, member count, master changes, nodes joined/left, JOIN_REJECTs, decrypt failures, config mismatches, split-brain merges) exposed via *get_statistics* and monitoring exporters.
 - **Events** — events raised on state transitions (became master, demoted, node joined/left, split-brain merged, config mismatch, authentication reject), named `E_CL_CTR_*` and consumable from an *event_route* or any event subscriber transport.
 - **IPv6 multicast** — the control plane currently uses IPv4 multicast (groups in *224.0.0.0/4*). Add IPv6 multicast support (*ff00::/8* groups, *AF_INET6* sockets and membership) so the controller can run on IPv6-only or dual-stack deployments.
 
@@ -211,6 +211,7 @@
 #include "../../pvar.h"         /* pv_export_t - read-only $cl_ctr_* variables */
 
 #include "../clusterer/clusterer_ctrl.h"  /* set_my_identity, add_node, remove_node */
+#include "../clusterer/api.h"   /* set_state() - the 'full' maintenance level */
 
 #include <sys/timerfd.h>    /* timerfd_create(), timerfd_settime()            */
 #include "../../reactor_proc.h" /* reactor_proc_init/add_fd/loop              */
@@ -349,6 +350,12 @@ static inline long long cl_ctr_now_ms(void)
  * the master relays every node's in MASTER_ALIVE. */
 #define CL_CTR_MAINT_NONE           0
 #define CL_CTR_MAINT_EVICTED        1
+/* full: evicted, and every other node marks it down in its own clusterer
+ * (set_state STATE_DISABLED), so replication stops routing work to it */
+#define CL_CTR_MAINT_FULL           2
+/* any node -> group: put node [node_id 2B BE] into maintenance [state 1B];
+ * only the node named applies it, to itself, and announces it as usual */
+#define CL_CTR_PKT_MAINT_SET        0x11
 
 /* Consumer messaging (api.h): plaintext payload layout after type+seq is
  * [src_node_id u16 BE][chan_len u8][channel bytes][consumer payload].
@@ -1494,6 +1501,8 @@ extern char my_interface_buf[IF_NAMESIZE];
 extern uint16_t my_node_id;
 extern uint64_t cl_ctr_incarnation;
 extern clusterer_ctrl_binds_t clctl;
+extern struct clusterer_binds cl_api;     /* the public clusterer API */
+extern int cl_api_loaded;
 extern int clctl_loaded;
 extern int manage_shtags;
 extern int consumer_retries;
@@ -1592,7 +1601,7 @@ int cl_ctr_on_retx_tfd(int fd, void *param, int was_timeout);
 
 /* cl_ctr_peers.c */
 int cl_ctr_find_peer(int cid, int nid, int *is_master, int *is_backup,
-                        char *ipbuf, int ipbuf_sz);
+                        int *maint, char *ipbuf, int ipbuf_sz);
 unsigned int ip_to_num(const char *ip);
 void cl_ctr_prune_stale(cl_ctr_cluster_t *cl);
 void cl_ctr_apply_master_from_list_locked(const char *master_ip, cl_ctr_cluster_t *cl);
@@ -1630,11 +1639,19 @@ int  cl_ctr_maint_parse(const char *s, int len);
 void cl_ctr_maint_sync(cl_ctr_cluster_t *cl);
 void cl_ctr_rpc_maint(int sender, void *param);
 int  cl_ctr_set_my_maint(cl_ctr_cluster_t *cl, int st);
+int  cl_ctr_set_node_maint(cl_ctr_cluster_t *cl, uint16_t node_id, int st);
 void cl_ctr_build_maint_bitmap(cl_ctr_cluster_t *cl, unsigned char *bm);
 int  cl_ctr_apply_maint_bitmap(cl_ctr_cluster_t *cl, const unsigned char *bm,
+                               const unsigned char *bm_full,
                                const char *master_ip);
+void cl_ctr_build_maint_full_bitmap(cl_ctr_cluster_t *cl, unsigned char *bm);
 void cl_ctr_raise_maint_event(cl_ctr_cluster_t *cl, int node_id, int st);
 void cl_ctr_maint_peer_changed(cl_ctr_cluster_t *cl, uint16_t node_id, int st);
+void cl_ctr_maint_changed(cl_ctr_cluster_t *cl, uint16_t node_id, int old_st,
+                          int st);
+int  cl_ctr_send_maint_set(cl_ctr_cluster_t *cl, uint16_t node_id, int st);
+void cl_ctr_handle_maint_set(const char *sender_ip, const char *payload,
+                             int payload_len, cl_ctr_cluster_t *cl);
 void cl_ctr_reelect_now(cl_ctr_cluster_t *cl, const char *why);
 long long cl_ctr_master_timeout_ms(cl_ctr_cluster_t *cl);
 void cl_ctr_arm_master_watchdog(cl_ctr_cluster_t *cl);
 
@@ -538,12 +538,15 @@ void cl_ctr_request_rekey(cl_ctr_cluster_t *cl)
 
 const char *cl_ctr_maint_name(int st)
 {
-    return st == CL_CTR_MAINT_EVICTED ? "evicted" : "none";
+    return st == CL_CTR_MAINT_FULL    ? "full"
+         : st == CL_CTR_MAINT_EVICTED ? "evicted" : "none";
 }
 
 /* "evicted"/"on"/"1" -> CL_CTR_MAINT_EVICTED, "none"/"off"/"0" -> NONE, else -1 */
 int cl_ctr_maint_parse(const char *s, int len)
 {
+    if (len == 4 && strncasecmp(s, "full", 4) == 0)
+        return CL_CTR_MAINT_FULL;
     if ((len == 7 && strncasecmp(s, "evicted", 7) == 0) ||
         (len == 2 && strncasecmp(s, "on", 2) == 0) ||
         (len == 1 && s[0] == '1'))
@@ -603,19 +606,22 @@ void cl_ctr_reelect_now(cl_ctr_cluster_t *cl, const char *why)
  */
 void cl_ctr_maint_sync(cl_ctr_cluster_t *cl)
 {
-    int i, st, was_master = 0;
+    int i, st, old_st, was_master = 0;
+    uint16_t me = 0;
 
     lock_start_write(cl->peers->lock);
     st = cl->peers->my_maint;
     if (st == cl->maint_adv) {
         lock_stop_write(cl->peers->lock);
         return;
     }
+    old_st        = cl->maint_adv;
     cl->maint_adv = (uint8_t)st;
     for (i = 0; i < cl->peers->count; i++)
         if (strcmp(cl->peers->entries[i].ip, my_ip) == 0) {
             cl->peers->entries[i].maint = (uint8_t)st;
             was_master = cl->peers->entries[i].is_master;
+            me = cl->peers->entries[i].node_id;
         }
     lock_stop_write(cl->peers->lock);
 
@@ -624,7 +630,7 @@ void cl_ctr_maint_sync(cl_ctr_cluster_t *cl)
             cl_ctr_maint_name(st),
             was_master && st != CL_CTR_MAINT_NONE
                 ? " - it is the master and hands over" : "");
-    cl_ctr_raise_maint_event(cl, my_node_id, st);
+    cl_ctr_maint_changed(cl, me, old_st, st);
     cl_ctr_send_alive(cl->sock, cl);
     if (was_master && st != CL_CTR_MAINT_NONE) {
         cl_ctr_send_master_alive(cl->sock, cl);
@@ -638,6 +644,55 @@ void cl_ctr_rpc_maint(int sender, void *param)
     cl_ctr_maint_sync((cl_ctr_cluster_t *)param);
 }
 
+/* An operator's request, made on this node, for ANOTHER node's maintenance
+ * state.  The worker multicasts it (it owns the sequence space); the node
+ * named applies it to itself (cl_ctr_handle_maint_set()). */
+typedef struct {
+    cl_ctr_cluster_t *cl;
+    uint16_t          node_id;
+    uint8_t           st;
+} cl_ctr_maint_req_t;
+
+static void cl_ctr_rpc_maint_remote(int sender, void *param)
+{
+    cl_ctr_maint_req_t *r = (cl_ctr_maint_req_t *)param;
+
+    if (cl_ctr_send_maint_set(r->cl, r->node_id, r->st) < 0)
+        LM_WARN("clusterer_controller: [cluster %d] could not send the request "
+                "for node %u to go into maintenance state %s\n",
+                r->cl->cluster_id, r->node_id, cl_ctr_maint_name(r->st));
+    else
+        LM_INFO("clusterer_controller: [cluster %d] asked node %u into "
+                "maintenance state %s\n", r->cl->cluster_id, r->node_id,
+                cl_ctr_maint_name(r->st));
+    shm_free(r);
+}
+
+/* Request node @node_id's maintenance state @st (MI, any process).
+ * Returns 0, or -1 when the worker is not up yet or out of memory. */
+int cl_ctr_set_node_maint(cl_ctr_cluster_t *cl, uint16_t node_id, int st)
+{
+    cl_ctr_maint_req_t *r;
+    int proc_no;
+
+    lock_start_read(cl->peers->lock);
+    proc_no = cl->peers->worker_proc_no;
+    lock_stop_read(cl->peers->lock);
+    if (proc_no < 0)
+        return -1;
+    r = shm_malloc(sizeof *r);
+    if (!r)
+        return -1;
+    r->cl      = cl;
+    r->node_id = node_id;
+    r->st      = (uint8_t)st;
+    if (ipc_send_rpc(proc_no, cl_ctr_rpc_maint_remote, r) < 0) {
+        shm_free(r);
+        return -1;
+    }
+    return 0;
+}
+
 /*
  * cl_ctr_maint_peer_changed() - a peer announced a new maintenance state
  * (master path: heard in its ALIVE).  Raises the event, and when it went
@@ -648,7 +703,6 @@ void cl_ctr_maint_peer_changed(cl_ctr_cluster_t *cl, uint16_t node_id, int st)
 {
     int cleared = 0, im;
 
-    cl_ctr_raise_maint_event(cl, node_id, st);
     if (st == CL_CTR_MAINT_NONE || node_id == 0)
         return;
     lock_start_write(cl->peers->lock);
@@ -733,3 +787,43 @@ void cl_ctr_isolation_round(cl_ctr_cluster_t *cl, int i_am_master)
         cl_ctr_apply_shtags(cl);
     }
 }
+
+/*
+ * cl_ctr_maint_changed() - node [node_id]'s maintenance state went from
+ * @old_st to @st, as this node learned it (its own request, a member's ALIVE
+ * on the master, the master's relay on a member).  Raises the event and, for
+ * another node entering or leaving the 'full' level, marks it down or up in
+ * this node's clusterer, so replication stops (or resumes) routing work to
+ * it.  A node does not disable itself: its peers do.  Called without the
+ * peers lock held.
+ */
+void cl_ctr_maint_changed(cl_ctr_cluster_t *cl, uint16_t node_id, int old_st,
+                          int st)
+{
+    uint16_t me = 0;
+    int k;
+
+    cl_ctr_raise_maint_event(cl, node_id, st);
+    if (node_id == 0 || !cl_api_loaded || !cl_api.set_state)
+        return;
+    /* this node's id in THIS cluster (it may differ per cluster): disabling
+     * ourselves in clusterer would cut every link we have */
+    lock_start_read(cl->peers->lock);
+    for (k = 0; k < cl->peers->count; k++)
+        if (strcmp(cl->peers->entries[k].ip, my_ip) == 0)
+            me = cl->peers->entries[k].node_id;
+    lock_stop_read(cl->peers->lock);
+    if (node_id == me)
+        return;
+    if (st == CL_CTR_MAINT_FULL && old_st != CL_CTR_MAINT_FULL) {
+        if (cl_api.set_state(cl->cluster_id, node_id, STATE_DISABLED) == 0)
+            LM_INFO("clusterer_controller: [cluster %d] node %u is in full "
+                    "maintenance - disabled in clusterer here\n",
+                    cl->cluster_id, node_id);
+    } else if (old_st == CL_CTR_MAINT_FULL && st != CL_CTR_MAINT_FULL) {
+        if (cl_api.set_state(cl->cluster_id, node_id, STATE_ENABLED) == 0)
+            LM_INFO("clusterer_controller: [cluster %d] node %u left full "
+                    "maintenance - enabled in clusterer here\n",
+                    cl->cluster_id, node_id);
+    }
+}