1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <stdlib.h>
28 #include <strings.h>
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <netinet/in.h>
32 #include <stddef.h>
33 #include <libilb_impl.h>
34 #include <libilb.h>
35
36 /*
37 * Create a health check, returning a health check handle upon success.
38 * Health check created will be recorded in persistent datastore.
39 */
40 ilb_status_t
ilb_create_hc(ilb_handle_t h,const ilb_hc_info_t * hc)41 ilb_create_hc(ilb_handle_t h, const ilb_hc_info_t *hc)
42 {
43 ilb_status_t rc;
44 ilb_comm_t *ic;
45 size_t ic_sz;
46
47 if (h == ILB_INVALID_HANDLE || hc == NULL || *hc->hci_name == '\0' ||
48 hc->hci_timeout < 0 || hc->hci_count < 0 ||
49 hc->hci_interval <= hc->hci_timeout * hc->hci_count)
50 return (ILB_STATUS_EINVAL);
51
52 if ((ic = i_ilb_alloc_req(ILBD_CREATE_HC, &ic_sz)) == NULL)
53 return (ILB_STATUS_ENOMEM);
54
55 (void) memcpy(&ic->ic_data, hc, sizeof (ilb_hc_info_t));
56
57 rc = i_ilb_do_comm(h, ic, ic_sz, ic, &ic_sz);
58 if (rc != ILB_STATUS_OK)
59 goto out;
60
61 if (ic->ic_cmd != ILBD_CMD_OK)
62 rc = *(ilb_status_t *)&ic->ic_data;
63
64 out:
65 free(ic);
66 return (rc);
67 }
68
69 /*
70 * Given a health check handle, destroy the corresponding health check.
71 * Persistent datastore will be updated as well.
72 */
73 ilb_status_t
ilb_destroy_hc(ilb_handle_t h,const char * hcname)74 ilb_destroy_hc(ilb_handle_t h, const char *hcname)
75 {
76 ilb_status_t rc;
77 ilb_comm_t *ic;
78 size_t ic_sz;
79
80 if (h == ILB_INVALID_HANDLE || hcname == NULL || *hcname == '\0')
81 return (ILB_STATUS_EINVAL);
82
83 if ((ic = i_ilb_alloc_req(ILBD_DESTROY_HC, &ic_sz)) == NULL)
84 return (ILB_STATUS_ENOMEM);
85
86 (void) strlcpy((char *)&ic->ic_data, hcname, sizeof (ilbd_name_t));
87
88 rc = i_ilb_do_comm(h, ic, ic_sz, ic, &ic_sz);
89 if (rc != ILB_STATUS_OK)
90 goto out;
91
92 if (ic->ic_cmd != ILBD_CMD_OK)
93 rc = *(ilb_status_t *)&ic->ic_data;
94
95 out:
96 free(ic);
97 return (rc);
98 }
99
100 /*
101 * Given a health check name, get hc info associated with this handle
102 */
103 ilb_status_t
ilb_get_hc_info(ilb_handle_t h,const char * name,ilb_hc_info_t * hcp)104 ilb_get_hc_info(ilb_handle_t h, const char *name, ilb_hc_info_t *hcp)
105 {
106 ilb_status_t rc;
107 ilb_comm_t *ic, *rbuf;
108 size_t ic_sz, rbufsz;
109
110 if (h == ILB_INVALID_HANDLE || name == NULL || hcp == NULL)
111 return (ILB_STATUS_EINVAL);
112
113 if ((ic = i_ilb_alloc_req(ILBD_GET_HC_INFO, &ic_sz)) == NULL)
114 return (ILB_STATUS_ENOMEM);
115 rbufsz = sizeof (ilb_comm_t) + sizeof (ilb_hc_info_t);
116 if ((rbuf = malloc(rbufsz)) == NULL) {
117 free(ic);
118 return (ILB_STATUS_ENOMEM);
119 }
120
121 (void) strlcpy((char *)&ic->ic_data, name, sizeof (ilbd_name_t));
122
123 rc = i_ilb_do_comm(h, ic, ic_sz, rbuf, &rbufsz);
124 if (rc != ILB_STATUS_OK)
125 goto out;
126
127 if (rbuf->ic_cmd != ILBD_CMD_OK) {
128 rc = *(ilb_status_t *)&rbuf->ic_data;
129 goto out;
130 }
131 (void) memcpy(hcp, &rbuf->ic_data, sizeof (*hcp));
132
133 out:
134 free(ic);
135 free(rbuf);
136 return (rc);
137 }
138
139 /*
140 * Walk through all health checks, will need if we implement list-hc
141 */
142 ilb_status_t
ilb_walk_hc(ilb_handle_t h,hc_walkerfunc_t func,void * arg)143 ilb_walk_hc(ilb_handle_t h, hc_walkerfunc_t func, void *arg)
144 {
145 ilb_status_t rc;
146 ilb_hc_info_t hc_info;
147 ilbd_namelist_t *hc_names;
148 ilb_comm_t ic, *rbuf;
149 size_t rbufsz;
150 int i;
151
152 rbufsz = ILBD_MSG_SIZE;
153 if ((rbuf = malloc(rbufsz)) == NULL)
154 return (ILB_STATUS_ENOMEM);
155 ic.ic_cmd = ILBD_RETRIEVE_HC_NAMES;
156
157 rc = i_ilb_do_comm(h, &ic, sizeof (ic), rbuf, &rbufsz);
158 if (rc != ILB_STATUS_OK)
159 goto out;
160 if (rbuf->ic_cmd != ILBD_CMD_OK) {
161 rc = *(ilb_status_t *)&rbuf->ic_data;
162 goto out;
163 }
164
165 hc_names = (ilbd_namelist_t *)&rbuf->ic_data;
166 for (i = 0; i < hc_names->ilbl_count; i++) {
167 rc = ilb_get_hc_info(h, hc_names->ilbl_name[i], &hc_info);
168 /*
169 * Since getting the list of hc names and getting the info
170 * of each of them are not atomic, some hc objects may have
171 * been deleted. If this is the case, just skip them.
172 */
173 if (rc == ILB_STATUS_ENOENT) {
174 rc = ILB_STATUS_OK;
175 continue;
176 } else if (rc != ILB_STATUS_OK) {
177 break;
178 }
179 rc = func(h, &hc_info, arg);
180 }
181
182 out:
183 free(rbuf);
184 return (rc);
185 }
186
187 static ilb_status_t
ilb_get_hc_srvs(ilb_handle_t h,const char * rulename,ilb_comm_t ** rbuf,size_t * rbufsz)188 ilb_get_hc_srvs(ilb_handle_t h, const char *rulename, ilb_comm_t **rbuf,
189 size_t *rbufsz)
190 {
191 ilb_status_t rc;
192 ilb_comm_t *ic, *tmp_rbuf;
193 size_t ic_sz;
194
195 if ((ic = i_ilb_alloc_req(ILBD_GET_HC_SRVS, &ic_sz)) == NULL)
196 return (ILB_STATUS_ENOMEM);
197 *rbufsz = ILBD_MSG_SIZE;
198 if ((tmp_rbuf = malloc(*rbufsz)) == NULL) {
199 free(ic);
200 return (ILB_STATUS_ENOMEM);
201 }
202
203 (void) strlcpy((char *)&ic->ic_data, rulename,
204 sizeof (ilbd_name_t));
205
206 rc = i_ilb_do_comm(h, ic, ic_sz, tmp_rbuf, rbufsz);
207 if (rc != ILB_STATUS_OK)
208 goto out;
209
210 if (tmp_rbuf->ic_cmd == ILBD_CMD_OK) {
211 *rbuf = tmp_rbuf;
212 return (rc);
213 }
214 rc = *(ilb_status_t *)&tmp_rbuf->ic_data;
215 out:
216 free(ic);
217 free(tmp_rbuf);
218 *rbuf = NULL;
219 return (rc);
220 }
221
222 ilb_status_t
ilb_walk_hc_srvs(ilb_handle_t h,hc_srvwalkerfunc_t fn,const char * rulename,void * arg)223 ilb_walk_hc_srvs(ilb_handle_t h, hc_srvwalkerfunc_t fn, const char *rulename,
224 void *arg)
225 {
226 ilb_status_t rc;
227 ilb_hc_rule_srv_t *srvs;
228 int i, j;
229 ilb_comm_t *rbuf;
230 size_t rbufsz;
231
232 if (rulename != NULL) {
233 rc = ilb_get_hc_srvs(h, rulename, &rbuf, &rbufsz);
234 if (rc != ILB_STATUS_OK)
235 return (rc);
236 srvs = (ilb_hc_rule_srv_t *)&rbuf->ic_data;
237 for (i = 0; i < srvs->rs_num_srvs; i++) {
238 rc = fn(h, &srvs->rs_srvs[i], arg);
239 if (rc != ILB_STATUS_OK)
240 break;
241 }
242 free(rbuf);
243 } else {
244 ilbd_namelist_t *names;
245 ilb_comm_t *srv_rbuf;
246 size_t srv_rbufsz;
247
248 rc = i_ilb_retrieve_rule_names(h, &rbuf, &rbufsz);
249 if (rc != ILB_STATUS_OK)
250 return (rc);
251 names = (ilbd_namelist_t *)&rbuf->ic_data;
252
253 for (i = 0; i < names->ilbl_count; i++) {
254 rc = ilb_get_hc_srvs(h, names->ilbl_name[i],
255 &srv_rbuf, &srv_rbufsz);
256
257 /* Not all rules have HC, so reset the error to OK. */
258 if (rc == ILB_STATUS_RULE_NO_HC) {
259 rc = ILB_STATUS_OK;
260 continue;
261 } else if (rc != ILB_STATUS_OK) {
262 break;
263 }
264
265 srvs = (ilb_hc_rule_srv_t *)&srv_rbuf->ic_data;
266 for (j = 0; j < srvs->rs_num_srvs; j++) {
267 rc = fn(h, &srvs->rs_srvs[j], arg);
268 if (rc != ILB_STATUS_OK)
269 break;
270 }
271 free(srv_rbuf);
272 }
273 free(rbuf);
274 }
275 return (rc);
276 }
277