diff --git a/src/cfgparse.c b/src/cfgparse.c
index 600f273..ecd4c9f 100644
--- a/src/cfgparse.c
+++ b/src/cfgparse.c
@@ -1941,7 +1941,7 @@
 			goto out;
 		}
 
-		for (curpeers = peers; curpeers != NULL; curpeers = curpeers->next) {
+		for (curpeers = cfg_peers; curpeers != NULL; curpeers = curpeers->next) {
 			/*
 			 * If there are two proxies with the same name only following
 			 * combinations are allowed:
@@ -1959,8 +1959,8 @@
 			goto out;
 		}
 
-		curpeers->next = peers;
-		peers = curpeers;
+		curpeers->next = cfg_peers;
+		cfg_peers = curpeers;
 		curpeers->conf.file = strdup(file);
 		curpeers->conf.line = linenum;
 		curpeers->last_change = now.tv_sec;
@@ -2040,7 +2040,7 @@
 		if (strcmp(newpeer->id, localpeer) == 0) {
 			/* Current is local peer, it define a frontend */
 			newpeer->local = 1;
-			peers->local = newpeer;
+			cfg_peers->local = newpeer;
 
 			if (!curpeers->peers_fe) {
 				if ((curpeers->peers_fe  = calloc(1, sizeof(struct proxy))) == NULL) {
@@ -8087,9 +8087,9 @@
 		}
 
 		if (curproxy->table.peers.name) {
-			struct peers *curpeers = peers;
+			struct peers *curpeers;
 
-			for (curpeers = peers; curpeers; curpeers = curpeers->next) {
+			for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
 				if (strcmp(curpeers->id, curproxy->table.peers.name) == 0) {
 					free((void *)curproxy->table.peers.name);
 					curproxy->table.peers.p = curpeers;
@@ -9108,15 +9108,15 @@
 		if (curproxy->table.peers.p)
 			curproxy->table.peers.p->peers_fe->bind_proc |= curproxy->bind_proc;
 
-	if (peers) {
-		struct peers *curpeers = peers, **last;
+	if (cfg_peers) {
+		struct peers *curpeers = cfg_peers, **last;
 		struct peer *p, *pb;
 
 		/* Remove all peers sections which don't have a valid listener,
 		 * which are not used by any table, or which are bound to more
 		 * than one process.
 		 */
-		last = &peers;
+		last = &cfg_peers;
 		while (*last) {
 			curpeers = *last;
 
diff --git a/src/haproxy.c b/src/haproxy.c
index a425744..2316100 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -1448,7 +1448,7 @@
 		struct peers *pr;
 		struct proxy *px;
 
-		for (pr = peers; pr; pr = pr->next)
+		for (pr = cfg_peers; pr; pr = pr->next)
 			if (pr->peers_fe)
 				break;
 
@@ -1662,11 +1662,11 @@
 	if (global.stats_fe)
 		global.maxsock += global.stats_fe->maxconn;
 
-	if (peers) {
+	if (cfg_peers) {
 		/* peers also need to bypass global maxconn */
-		struct peers *p = peers;
+		struct peers *p = cfg_peers;
 
-		for (p = peers; p; p = p->next)
+		for (p = cfg_peers; p; p = p->next)
 			if (p->peers_fe)
 				global.maxsock += p->peers_fe->maxconn;
 	}
@@ -2653,7 +2653,7 @@
 		}
 
 		/* we might have to unbind some peers sections from some processes */
-		for (curpeers = peers; curpeers; curpeers = curpeers->next) {
+		for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
 			if (!curpeers->peers_fe)
 				continue;
 
diff --git a/src/peers.c b/src/peers.c
index 9847cbd..f176d24 100644
--- a/src/peers.c
+++ b/src/peers.c
@@ -171,7 +171,7 @@
 #define PEER_MINOR_VER        1
 #define PEER_DWNGRD_MINOR_VER 0
 
-struct peers *peers = NULL;
+struct peers *cfg_peers = NULL;
 static void peer_session_forceshutdown(struct appctx *appctx);
 
 /* This function encode an uint64 to 'dynamic' length format.
@@ -743,19 +743,19 @@
 				/* if current peer is local */
                                 if (curpeer->local) {
                                         /* if current host need resyncfrom local and no process assined  */
-                                        if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
-                                            !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
+                                        if ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
+                                            !(curpeers->flags & PEERS_F_RESYNC_ASSIGN)) {
                                                 /* assign local peer for a lesson, consider lesson already requested */
                                                 curpeer->flags |= PEER_F_LEARN_ASSIGN;
-                                                peers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
+                                                curpeers->flags |= (PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
                                         }
 
                                 }
-                                else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
-                                         !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
+                                else if ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
+                                         !(curpeers->flags & PEERS_F_RESYNC_ASSIGN)) {
                                         /* assign peer for a lesson  */
                                         curpeer->flags |= PEER_F_LEARN_ASSIGN;
-                                        peers->flags |= PEERS_F_RESYNC_ASSIGN;
+                                        curpeers->flags |= PEERS_F_RESYNC_ASSIGN;
                                 }
 
 
@@ -823,7 +823,7 @@
 				curpeer->statuscode = atoi(trash.str);
 
 				/* Awake main task */
-				task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
+				task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
 
 				/* If status code is success */
 				if (curpeer->statuscode == PEER_SESS_SC_SUCCESSCODE) {
@@ -846,14 +846,14 @@
                                                 curpeer->flags |= PEER_F_TEACH_PROCESS;
 
                                         }
-                                        else if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
-                                                    !(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
+                                        else if ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMREMOTE &&
+                                                    !(curpeers->flags & PEERS_F_RESYNC_ASSIGN)) {
                                                 /* If peer is remote and resync from remote is needed,
                                                    and no peer currently assigned */
 
                                                 /* assign peer for a lesson */
                                                 curpeer->flags |= PEER_F_LEARN_ASSIGN;
-						peers->flags |= PEERS_F_RESYNC_ASSIGN;
+						curpeers->flags |= PEERS_F_RESYNC_ASSIGN;
 					}
 
 				}
@@ -966,8 +966,8 @@
 
 						if (curpeer->flags & PEER_F_LEARN_ASSIGN) {
 							curpeer->flags &= ~PEER_F_LEARN_ASSIGN;
-							peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
-							peers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
+							curpeers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
+							curpeers->flags |= (PEERS_F_RESYNC_LOCAL|PEERS_F_RESYNC_REMOTE);
 						}
 						curpeer->confirm++;
 					}
@@ -975,11 +975,11 @@
 
 						if (curpeer->flags & PEER_F_LEARN_ASSIGN) {
 							curpeer->flags &= ~PEER_F_LEARN_ASSIGN;
-							peers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
+							curpeers->flags &= ~(PEERS_F_RESYNC_ASSIGN|PEERS_F_RESYNC_PROCESS);
 
 							curpeer->flags |= PEER_F_LEARN_NOTUP2DATE;
-							peers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
-							task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
+							curpeers->resync_timeout = tick_add(now_ms, MS_TO_TICKS(5000));
+							task_wakeup(curpeers->sync_task, TASK_WOKEN_MSG);
 						}
 						curpeer->confirm++;
 					}
@@ -1350,8 +1350,8 @@
 
 				/* Need to request a resync */
                                 if ((curpeer->flags & PEER_F_LEARN_ASSIGN) &&
-                                        (peers->flags & PEERS_F_RESYNC_ASSIGN) &&
-                                        !(peers->flags & PEERS_F_RESYNC_PROCESS)) {
+                                        (curpeers->flags & PEERS_F_RESYNC_ASSIGN) &&
+                                        !(curpeers->flags & PEERS_F_RESYNC_PROCESS)) {
 					unsigned char msg[2];
 
                                         /* Current peer was elected to request a resync */
@@ -1367,7 +1367,7 @@
                                                 appctx->st0 = PEER_SESS_ST_END;
                                                 goto switchstate;
                                         }
-                                        peers->flags |= PEERS_F_RESYNC_PROCESS;
+                                        curpeers->flags |= PEERS_F_RESYNC_PROCESS;
                                 }
 
 				/* Nothing to read, now we start to write */
@@ -1640,7 +1640,7 @@
 
                                         /* Current peer was elected to request a resync */
 					msg[0] = PEER_MSG_CLASS_CONTROL;
-					msg[1] = ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED) ? PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
+					msg[1] = ((curpeers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FINISHED) ? PEER_MSG_CTRL_RESYNCFINISHED : PEER_MSG_CTRL_RESYNCPARTIAL;
 					/* process final lesson message */
 					repl = bi_putblk(si_ic(si), (char *)msg, sizeof(msg));
 					if (repl <= 0) {
diff --git a/src/proxy.c b/src/proxy.c
index f6a3214..1481089 100644
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -1021,7 +1021,7 @@
 		p = p->next;
 	}
 
-	prs = peers;
+	prs = cfg_peers;
 	while (prs) {
 		if (prs->peers_fe)
 			stop_proxy(prs->peers_fe);
@@ -1195,7 +1195,7 @@
 		p = p->next;
 	}
 
-	prs = peers;
+	prs = cfg_peers;
 	while (prs) {
 		if (prs->peers_fe)
 			err |= !pause_proxy(prs->peers_fe);
@@ -1229,7 +1229,7 @@
 		p = p->next;
 	}
 
-	prs = peers;
+	prs = cfg_peers;
 	while (prs) {
 		if (prs->peers_fe)
 			err |= !resume_proxy(prs->peers_fe);