1 /*	$OpenBSD: carp.c,v 1.14 2026/03/02 19:28:01 rsadowski Exp $ */
2 
3 /*
4  * Copyright (c) 2006 Henning Brauer <henning@openbsd.org>
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 
19 #include <sys/types.h>
20 #include <sys/socket.h>
21 #include <sys/queue.h>
22 #include <sys/ioctl.h>
23 
24 #include <net/if.h>
25 
26 #include <errno.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 
31 #include "relayd.h"
32 #include "log.h"
33 
34 struct carpgroup {
35 	TAILQ_ENTRY(carpgroup)	 entry;
36 	char			*group;
37 	int			 do_demote;
38 	int			 changed_by;
39 };
40 
41 TAILQ_HEAD(carpgroups, carpgroup)	carpgroups =
42     TAILQ_HEAD_INITIALIZER(carpgroups);
43 
44 struct carpgroup	*carp_group_find(char *group);
45 int			 carp_demote_ioctl(char *, int);
46 
47 struct carpgroup *
48 carp_group_find(char *group)
49 {
50 	struct carpgroup	*c;
51 
52 	TAILQ_FOREACH(c, &carpgroups, entry)
53 		if (!strcmp(c->group, group))
54 			return (c);
55 
56 	return (NULL);
57 }
58 
59 int
60 carp_demote_init(char *group, int force)
61 {
62 	struct carpgroup	*c;
63 	int			 level;
64 
65 	if (carp_group_find(group) != NULL)
66 		return (0);
67 
68 	if ((c = calloc(1, sizeof(struct carpgroup))) == NULL) {
69 		log_warn("%s: calloc", __func__);
70 		return (-1);
71 	}
72 	if ((c->group = strdup(group)) == NULL) {
73 		log_warn("%s: strdup", __func__);
74 		free(c);
75 		return (-1);
76 	}
77 	/* only demote if this group already is demoted */
78 	if ((level = carp_demote_get(group)) == -1) {
79 		free(c->group);
80 		free(c);
81 		return (-1);
82 	}
83 	if (level > 0 || force)
84 		c->do_demote = 1;
85 
86 	TAILQ_INSERT_TAIL(&carpgroups, c, entry);
87 	return (0);
88 }
89 
90 void
91 carp_demote_shutdown(void)
92 {
93 	struct carpgroup	*c;
94 
95 	while ((c = TAILQ_FIRST(&carpgroups)) != NULL) {
96 		TAILQ_REMOVE(&carpgroups, c, entry);
97 		if (c->do_demote && c->changed_by > 0)
98 			carp_demote_ioctl(c->group, -c->changed_by);
99 
100 		free(c->group);
101 		free(c);
102 	}
103 }
104 
105 int
106 carp_demote_get(char *group)
107 {
108 	int			s;
109 	struct ifgroupreq	ifgr;
110 
111 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
112 		log_warn("%s: socket", __func__);
113 		return (-1);
114 	}
115 
116 	bzero(&ifgr, sizeof(ifgr));
117 	if (strlcpy(ifgr.ifgr_name, group, sizeof(ifgr.ifgr_name)) >=
118 	    sizeof(ifgr.ifgr_name)) {
119 		log_warn("%s: invalid group", __func__);
120 		close(s);
121 		return (-1);
122 	}
123 
124 	if (ioctl(s, SIOCGIFGATTR, (caddr_t)&ifgr) == -1) {
125 		if (errno == ENOENT)
126 			log_warnx("%s: group \"%s\" does not exist",
127 			    __func__, group);
128 		else
129 			log_warn("%s: ioctl", __func__);
130 		close(s);
131 		return (-1);
132 	}
133 
134 	close(s);
135 	return ((int)ifgr.ifgr_attrib.ifg_carp_demoted);
136 }
137 
138 int
139 carp_demote_set(char *group, int demote)
140 {
141 	struct carpgroup	*c;
142 
143 	if ((c = carp_group_find(group)) == NULL) {
144 		log_warnx("%s: carp group %s not found", __func__, group);
145 		return (-1);
146 	}
147 
148 	if (c->changed_by + demote < 0) {
149 		log_warnx("%s: changed_by + demote < 0", __func__);
150 		return (-1);
151 	}
152 
153 	if (c->do_demote && carp_demote_ioctl(group, demote) == -1)
154 		return (-1);
155 
156 	c->changed_by += demote;
157 
158 	/* enable demotion when we return to 0, i. e. all sessions up */
159 	if (demote < 0 && c->changed_by == 0)
160 		c->do_demote = 1;
161 
162 	return (0);
163 }
164 
165 int
166 carp_demote_reset(char *group, int value)
167 {
168 	int			 level;
169 	int			 demote = 0;
170 
171 	if (value < 0) {
172 		log_warnx("%s: value < 0", __func__);
173 		return (-1);
174 	}
175 
176 	if ((level = carp_demote_get(group)) == -1)
177 		return (-1);
178 	if (level == value)
179 		return (0);
180 
181 	demote -= level;
182 	demote += value;
183 
184 	if (carp_demote_ioctl(group, demote) == -1)
185 		return (-1);
186 
187 	return (0);
188 }
189 
190 int
191 carp_demote_ioctl(char *group, int demote)
192 {
193 	int			s, res;
194 	struct ifgroupreq	ifgr;
195 
196 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
197 		log_warn("%s: socket", __func__);
198 		return (-1);
199 	}
200 
201 	bzero(&ifgr, sizeof(ifgr));
202 	if (strlcpy(ifgr.ifgr_name, group, sizeof(ifgr.ifgr_name)) >=
203 	    sizeof(ifgr.ifgr_name)) {
204 		log_warn("%s: invalid group", __func__);
205 		close(s);
206 		return (-1);
207 	}
208 	ifgr.ifgr_attrib.ifg_carp_demoted = demote;
209 
210 	if ((res = ioctl(s, SIOCSIFGATTR, (caddr_t)&ifgr)) == -1)
211 		log_warn("%s: unable to %s the demote state "
212 		    "of group '%s'", __func__,
213 		    (demote > 0) ? "increment" : "decrement", group);
214 	else
215 		log_info("%s the demote state of group '%s'",
216 		    (demote > 0) ? "incremented" : "decremented", group);
217 
218 	close(s);
219 	return (res);
220 }