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 */
40ilb_status_t
41ilb_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
64out:
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 */
73ilb_status_t
74ilb_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
95out:
96	free(ic);
97	return (rc);
98}
99
100/*
101 * Given a health check name, get hc info associated with this handle
102 */
103ilb_status_t
104ilb_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
133out:
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 */
142ilb_status_t
143ilb_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
182out:
183	free(rbuf);
184	return (rc);
185}
186
187static ilb_status_t
188ilb_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;
215out:
216	free(ic);
217	free(tmp_rbuf);
218	*rbuf = NULL;
219	return (rc);
220}
221
222ilb_status_t
223ilb_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