1 /*-
2  * Copyright (C) 2011 Hiroki Sato <hrs@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
21  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
24  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: stable/10/usr.sbin/rtadvd/control_server.c 225519 2011-09-12 23:52:55Z hrs $
27  *
28  */
29 
30 #include <sys/queue.h>
31 #include <sys/types.h>
32 #include <sys/socket.h>
33 #include <sys/stat.h>
34 #include <sys/un.h>
35 #include <sys/uio.h>
36 #include <net/if.h>
37 #include <net/if_dl.h>
38 #include <netinet/in.h>
39 #include <netinet/icmp6.h>
40 #include <fcntl.h>
41 #include <errno.h>
42 #include <netdb.h>
43 #include <unistd.h>
44 #include <signal.h>
45 #include <string.h>
46 #include <stdarg.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <syslog.h>
50 
51 #include "pathnames.h"
52 #include "rtadvd.h"
53 #include "if.h"
54 #include "config.h"
55 #include "control.h"
56 #include "control_server.h"
57 #include "timer.h"
58 
59 static char *do_reload_ifname;
60 static int do_reload;
61 static int do_shutdown;
62 
set_do_reload(int sig __unused)63 void set_do_reload(int sig __unused)	{ do_reload = 1; }
set_do_reload_ifname(char * ifname)64 void set_do_reload_ifname(char *ifname){ do_reload_ifname = ifname; }
set_do_shutdown(int sig __unused)65 void set_do_shutdown(int sig __unused)	{ do_shutdown = 1; }
reset_do_reload(void)66 void reset_do_reload(void)	{ do_reload = 0; do_reload_ifname = NULL; }
reset_do_shutdown(void)67 void reset_do_shutdown(void)	{ do_shutdown = 0; }
is_do_reload(void)68 int is_do_reload(void)		{ return (do_reload); }
is_do_shutdown(void)69 int is_do_shutdown(void)	{ return (do_shutdown); }
reload_ifname(void)70 char *reload_ifname(void)	{ return (do_reload_ifname); }
71 
72 #define	DEF_PL_HANDLER(key)	{ #key, cm_getprop_##key }
73 
74 static int cm_getprop_echo(struct ctrl_msg_pl *);
75 static int cm_getprop_version(struct ctrl_msg_pl *);
76 static int cm_getprop_ifilist(struct ctrl_msg_pl *);
77 static int cm_getprop_ifi(struct ctrl_msg_pl *);
78 static int cm_getprop_ifi_ra_timer(struct ctrl_msg_pl *);
79 static int cm_getprop_rai(struct ctrl_msg_pl *);
80 static int cm_getprop_pfx(struct ctrl_msg_pl *);
81 static int cm_getprop_rdnss(struct ctrl_msg_pl *);
82 static int cm_getprop_dnssl(struct ctrl_msg_pl *);
83 static int cm_getprop_rti(struct ctrl_msg_pl *);
84 
85 static int cm_setprop_reload(struct ctrl_msg_pl *);
86 static int cm_setprop_enable(struct ctrl_msg_pl *);
87 static int cm_setprop_disable(struct ctrl_msg_pl *);
88 
89 static struct dispatch_table {
90 	const char	*dt_comm;
91 	int		(*dt_act)(struct ctrl_msg_pl *cp);
92 } getprop_dtable[] = {
93 	{ "",	cm_getprop_echo },
94 	DEF_PL_HANDLER(echo),
95 	DEF_PL_HANDLER(version),
96 	DEF_PL_HANDLER(ifilist),
97 	DEF_PL_HANDLER(ifi),
98 	DEF_PL_HANDLER(ifi_ra_timer),
99 	DEF_PL_HANDLER(rai),
100 	DEF_PL_HANDLER(rti),
101 	DEF_PL_HANDLER(pfx),
102 	DEF_PL_HANDLER(rdnss),
103 	DEF_PL_HANDLER(dnssl),
104 };
105 
106 static int
cm_getprop_echo(struct ctrl_msg_pl * cp)107 cm_getprop_echo(struct ctrl_msg_pl *cp)
108 {
109 
110 	syslog(LOG_DEBUG, "<%s> enter", __func__);
111 	cp->cp_val = strdup("");
112 	cp->cp_val_len = strlen(cp->cp_val) + 1;
113 
114 	return (0);
115 }
116 
117 static int
cm_getprop_version(struct ctrl_msg_pl * cp)118 cm_getprop_version(struct ctrl_msg_pl *cp)
119 {
120 
121 	syslog(LOG_DEBUG, "<%s> enter", __func__);
122 	cp->cp_val = strdup(CM_VERSION_STR);
123 	cp->cp_val_len = strlen(cp->cp_val) + 1;
124 
125 	return (0);
126 }
127 
128 static int
cm_getprop_ifilist(struct ctrl_msg_pl * cp)129 cm_getprop_ifilist(struct ctrl_msg_pl *cp)
130 {
131 	struct ifinfo *ifi;
132 	char *p;
133 	size_t len;
134 
135 	syslog(LOG_DEBUG, "<%s> enter", __func__);
136 
137 	len = 0;
138 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
139 		len += strlen(ifi->ifi_ifname) + 1;
140 	}
141 
142 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
143 
144 	p = malloc(len);
145 	if (p == NULL)
146 		exit(1);
147 	memset(p, 0, len);
148 	cp->cp_val = p;
149 
150 	if (len > 0)
151 		TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
152 			syslog(LOG_DEBUG, "<%s> add ifname=%s(%d)",
153 			    __func__, ifi->ifi_ifname, ifi->ifi_ifindex);
154 			strcpy(p, ifi->ifi_ifname);
155 			p += strlen(ifi->ifi_ifname) + 1;
156 		}
157 	cp->cp_val_len = p - cp->cp_val;
158 
159 	return (0);
160 }
161 
162 static int
cm_getprop_ifi(struct ctrl_msg_pl * cp)163 cm_getprop_ifi(struct ctrl_msg_pl *cp)
164 {
165 	struct ifinfo *ifi;
166 	char *p;
167 	size_t len;
168 
169 	syslog(LOG_DEBUG, "<%s> enter", __func__);
170 
171 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
172 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
173 			break;
174 	}
175 	if (ifi == NULL) {
176 		syslog(LOG_ERR, "<%s> %s not found", __func__,
177 		    cp->cp_ifname);
178 		return (1);
179 	}
180 
181 	p = malloc(sizeof(*ifi));
182 	if (p == NULL)
183 		exit(1);
184 	len = cm_str2bin(p, ifi, sizeof(*ifi));
185 
186 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
187 
188 	if (len == 0)
189 		return (1);
190 
191 	cp->cp_val = p;
192 	cp->cp_val_len = len;
193 
194 	return (0);
195 }
196 
197 static int
cm_getprop_rai(struct ctrl_msg_pl * cp)198 cm_getprop_rai(struct ctrl_msg_pl *cp)
199 {
200 	struct ifinfo *ifi;
201 	struct rainfo *rai;
202 	char *p;
203 	size_t len;
204 
205 	syslog(LOG_DEBUG, "<%s> enter", __func__);
206 
207 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
208 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
209 			break;
210 	}
211 	if (ifi == NULL) {
212 		syslog(LOG_ERR, "<%s> %s not found", __func__,
213 		    cp->cp_ifname);
214 		return (1);
215 	}
216 	if ((rai = ifi->ifi_rainfo) == NULL) {
217 		syslog(LOG_ERR, "<%s> %s has no rainfo", __func__,
218 		    cp->cp_ifname);
219 		return (1);
220 	}
221 
222 	p = malloc(sizeof(*rai));
223 	if (p == NULL)
224 		exit(1);
225 	len = cm_str2bin(p, rai, sizeof(*rai));
226 
227 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
228 
229 	if (len == 0)
230 		return (1);
231 
232 	cp->cp_val = p;
233 	cp->cp_val_len = len;
234 
235 	return (0);
236 }
237 
238 static int
cm_getprop_ifi_ra_timer(struct ctrl_msg_pl * cp)239 cm_getprop_ifi_ra_timer(struct ctrl_msg_pl *cp)
240 {
241 	struct ifinfo *ifi;
242 	struct rainfo *rai;
243 	struct rtadvd_timer	*rtimer;
244 	char *p;
245 	size_t len;
246 
247 	syslog(LOG_DEBUG, "<%s> enter", __func__);
248 
249 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
250 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
251 			break;
252 	}
253 	if (ifi == NULL) {
254 		syslog(LOG_ERR, "<%s> %s not found", __func__,
255 		    cp->cp_ifname);
256 		return (1);
257 	}
258 	if ((rai = ifi->ifi_rainfo) == NULL) {
259 		syslog(LOG_ERR, "<%s> %s has no rainfo", __func__,
260 		    cp->cp_ifname);
261 		return (1);
262 	}
263 	if ((rtimer = ifi->ifi_ra_timer) == NULL) {
264 		syslog(LOG_ERR, "<%s> %s has no ifi_ra_timer", __func__,
265 		    cp->cp_ifname);
266 		return (1);
267 	}
268 	p = malloc(sizeof(*rtimer));
269 	if (p == NULL)
270 		exit(1);
271 	len = cm_str2bin(p, rtimer, sizeof(*rtimer));
272 
273 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
274 
275 	if (len == 0)
276 		return (1);
277 
278 	cp->cp_val = p;
279 	cp->cp_val_len = len;
280 
281 	return (0);
282 }
283 
284 static int
cm_getprop_rti(struct ctrl_msg_pl * cp)285 cm_getprop_rti(struct ctrl_msg_pl *cp)
286 {
287 	struct ifinfo *ifi;
288 	struct rainfo *rai;
289 	struct rtinfo *rti;
290 	char *p;
291 	size_t len;
292 
293 	syslog(LOG_DEBUG, "<%s> enter", __func__);
294 
295 	len = 0;
296 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
297 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
298 			break;
299 	}
300 	if (ifi == NULL) {
301 		syslog(LOG_ERR, "<%s> %s not found", __func__,
302 		    cp->cp_ifname);
303 		return (1);
304 	}
305 	if (ifi->ifi_rainfo == NULL) {
306 		syslog(LOG_ERR, "<%s> %s has no rainfo", __func__,
307 		    cp->cp_ifname);
308 		return (1);
309 	}
310 	rai = ifi->ifi_rainfo;
311 	TAILQ_FOREACH(rti, &rai->rai_route, rti_next) {
312 		len += sizeof(*rti);
313 	}
314 
315 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
316 
317 	p = malloc(len);
318 	if (p == NULL)
319 		exit(1);
320 	memset(p, 0, len);
321 	cp->cp_val = p;
322 
323 	if (len > 0)
324 		TAILQ_FOREACH(rti, &rai->rai_route, rti_next) {
325 			memcpy(p, rti, sizeof(*rti));
326 			p += sizeof(*rti);
327 		}
328 	cp->cp_val_len = p - cp->cp_val;
329 
330 	return (0);
331 }
332 
333 static int
cm_getprop_pfx(struct ctrl_msg_pl * cp)334 cm_getprop_pfx(struct ctrl_msg_pl *cp)
335 {
336 	struct ifinfo *ifi;
337 	struct rainfo *rai;
338 	struct prefix *pfx;
339 	char *p;
340 	size_t len;
341 
342 	syslog(LOG_DEBUG, "<%s> enter", __func__);
343 
344 	len = 0;
345 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
346 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
347 			break;
348 	}
349 	if (ifi == NULL) {
350 		syslog(LOG_ERR, "<%s> %s not found", __func__,
351 		    cp->cp_ifname);
352 		return (1);
353 	}
354 	if (ifi->ifi_rainfo == NULL) {
355 		syslog(LOG_ERR, "<%s> %s has no rainfo", __func__,
356 		    cp->cp_ifname);
357 		return (1);
358 	}
359 	rai = ifi->ifi_rainfo;
360 	TAILQ_FOREACH(pfx, &rai->rai_prefix, pfx_next) {
361 		len += sizeof(*pfx);
362 	}
363 
364 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
365 
366 	p = malloc(len);
367 	if (p == NULL)
368 		exit(1);
369 	memset(p, 0, len);
370 	cp->cp_val = p;
371 
372 	if (len > 0)
373 		TAILQ_FOREACH(pfx, &rai->rai_prefix, pfx_next) {
374 			memcpy(p, pfx, sizeof(*pfx));
375 			p += sizeof(*pfx);
376 		}
377 	cp->cp_val_len = p - cp->cp_val;
378 
379 	return (0);
380 }
381 
382 static int
cm_getprop_rdnss(struct ctrl_msg_pl * cp)383 cm_getprop_rdnss(struct ctrl_msg_pl *cp)
384 {
385 	struct ifinfo *ifi;
386 	struct rainfo *rai;
387 	struct rdnss *rdn;
388 	struct rdnss_addr *rda;
389 	char *p;
390 	size_t len;
391 	uint16_t *rdn_cnt;
392 	uint16_t *rda_cnt;
393 
394 	syslog(LOG_DEBUG, "<%s> enter", __func__);
395 
396 	len = 0;
397 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
398 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
399 			break;
400 	}
401 	if (ifi == NULL) {
402 		syslog(LOG_ERR, "<%s> %s not found", __func__,
403 		    cp->cp_ifname);
404 		return (1);
405 	}
406 	if (ifi->ifi_rainfo == NULL) {
407 		syslog(LOG_ERR, "<%s> %s has no rainfo", __func__,
408 		    cp->cp_ifname);
409 		return (1);
410 	}
411 	rai = ifi->ifi_rainfo;
412 
413 	len = sizeof(*rdn_cnt);
414 	TAILQ_FOREACH(rdn, &rai->rai_rdnss, rd_next) {
415 		len += sizeof(*rdn);
416 		len += sizeof(*rda_cnt);
417 		TAILQ_FOREACH(rda, &rdn->rd_list, ra_next) {
418 			len += sizeof(*rda);
419 		}
420 	}
421 
422 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
423 
424 	p = malloc(len);
425 	if (p == NULL)
426 		exit(1);
427 	memset(p, 0, len);
428 	cp->cp_val = p;
429 
430 	rdn_cnt = (uint16_t *)p;
431 	p += sizeof(*rdn_cnt);
432 	TAILQ_FOREACH(rdn, &rai->rai_rdnss, rd_next) {
433 		*rdn_cnt += 1;
434 		memcpy(p, rdn, sizeof(*rdn));
435 		p += sizeof(*rdn);
436 
437 		rda_cnt = (uint16_t *)p;
438 		p += sizeof(*rda_cnt);
439 		TAILQ_FOREACH(rda, &rdn->rd_list, ra_next) {
440 			*rda_cnt += 1;
441 			memcpy(p, rda, sizeof(*rda));
442 			p += sizeof(*rda);
443 		}
444 	}
445 	syslog(LOG_DEBUG, "<%s> rdn_cnt = %d", __func__, *rdn_cnt);
446 	cp->cp_val_len = p - cp->cp_val;
447 
448 	return (0);
449 }
450 
451 static int
cm_getprop_dnssl(struct ctrl_msg_pl * cp)452 cm_getprop_dnssl(struct ctrl_msg_pl *cp)
453 {
454 	struct ifinfo *ifi;
455 	struct rainfo *rai;
456 	struct dnssl *dns;
457 	struct dnssl_addr *dna;
458 	char *p;
459 	size_t len;
460 	uint16_t *dns_cnt;
461 	uint16_t *dna_cnt;
462 
463 	syslog(LOG_DEBUG, "<%s> enter", __func__);
464 
465 	len = 0;
466 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
467 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
468 			break;
469 	}
470 	if (ifi == NULL) {
471 		syslog(LOG_ERR, "<%s> %s not found", __func__,
472 		    cp->cp_ifname);
473 		return (1);
474 	}
475 	if (ifi->ifi_rainfo == NULL) {
476 		syslog(LOG_ERR, "<%s> %s has no rainfo", __func__,
477 		    cp->cp_ifname);
478 		return (1);
479 	}
480 	rai = ifi->ifi_rainfo;
481 
482 	len = sizeof(*dns_cnt);
483 	TAILQ_FOREACH(dns, &rai->rai_dnssl, dn_next) {
484 		len += sizeof(*dns);
485 		len += sizeof(*dna_cnt);
486 		TAILQ_FOREACH(dna, &dns->dn_list, da_next) {
487 			len += sizeof(*dna);
488 		}
489 	}
490 
491 	syslog(LOG_DEBUG, "<%s> len = %zu", __func__, len);
492 
493 	p = malloc(len);
494 	if (p == NULL)
495 		exit(1);
496 	memset(p, 0, len);
497 	cp->cp_val = p;
498 
499 	dns_cnt = (uint16_t *)cp->cp_val;
500 	p += sizeof(*dns_cnt);
501 	TAILQ_FOREACH(dns, &rai->rai_dnssl, dn_next) {
502 		(*dns_cnt)++;
503 		memcpy(p, dns, sizeof(*dns));
504 		p += sizeof(*dns);
505 
506 		dna_cnt = (uint16_t *)p;
507 		p += sizeof(*dna_cnt);
508 		TAILQ_FOREACH(dna, &dns->dn_list, da_next) {
509 			(*dna_cnt)++;
510 			memcpy(p, dna, sizeof(*dna));
511 			p += sizeof(*dna);
512 		}
513 	}
514 	cp->cp_val_len = p - cp->cp_val;
515 
516 	return (0);
517 }
518 
519 int
cm_getprop(struct ctrl_msg_pl * cp)520 cm_getprop(struct ctrl_msg_pl *cp)
521 {
522 	size_t i;
523 
524 	syslog(LOG_DEBUG, "<%s> enter", __func__);
525 
526 	if (cp == NULL)
527 		return (1);
528 
529 	for (i = 0;
530 	     i < sizeof(getprop_dtable) / sizeof(getprop_dtable[0]);
531 	     i++) {
532 		if (strcmp(cp->cp_key, getprop_dtable[i].dt_comm) == 0)
533 			return (getprop_dtable[i].dt_act(cp));
534 	}
535 	return (1);
536 }
537 
538 int
cm_setprop(struct ctrl_msg_pl * cp)539 cm_setprop(struct ctrl_msg_pl *cp)
540 {
541 	syslog(LOG_DEBUG, "<%s> enter", __func__);
542 
543 	if (cp == NULL || cp->cp_key == NULL)
544 		return (1);
545 
546 	if (strncmp(cp->cp_key, "reload", sizeof("reload")) == 0)
547 		cm_setprop_reload(cp);
548 	else if (strncmp(cp->cp_key, "shutdown", sizeof("shutdown")) == 0)
549 		set_do_shutdown(0);
550 	else if (strncmp(cp->cp_key, "enable", sizeof("enable")) == 0)
551 		cm_setprop_enable(cp);
552 	else if (strncmp(cp->cp_key, "disable", sizeof("disable")) == 0)
553 		cm_setprop_disable(cp);
554 	else if (strncmp(cp->cp_key, "echo", 8) == 0)
555 		; 		/* do nothing */
556 	else
557 		return (1);
558 
559 	return (0);
560 }
561 
562 static int
cm_setprop_reload(struct ctrl_msg_pl * cp)563 cm_setprop_reload(struct ctrl_msg_pl *cp)
564 {
565 
566 	syslog(LOG_DEBUG, "<%s> enter", __func__);
567 
568 	set_do_reload_ifname(cp->cp_ifname);
569 	set_do_reload(1);
570 
571 	return (0);
572 }
573 
574 static int
cm_setprop_enable(struct ctrl_msg_pl * cp)575 cm_setprop_enable(struct ctrl_msg_pl *cp)
576 {
577 	struct ifinfo *ifi;
578 
579 	syslog(LOG_DEBUG, "<%s> enter", __func__);
580 
581 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
582 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
583 			break;
584 	}
585 	if (ifi == NULL) {
586 		syslog(LOG_ERR, "<%s> %s not found", __func__,
587 		    cp->cp_ifname);
588 		return (1);
589 	}
590 
591 	ifi->ifi_persist = 1;
592 	set_do_reload_ifname(ifi->ifi_ifname);
593 	set_do_reload(0);
594 
595 	return (0);
596 }
597 
598 static int
cm_setprop_disable(struct ctrl_msg_pl * cp)599 cm_setprop_disable(struct ctrl_msg_pl *cp)
600 {
601 	struct ifinfo *ifi;
602 
603 	syslog(LOG_DEBUG, "<%s> enter", __func__);
604 
605 	TAILQ_FOREACH(ifi, &ifilist, ifi_next) {
606 		if (strcmp(cp->cp_ifname, ifi->ifi_ifname) == 0)
607 			break;
608 	}
609 	if (ifi == NULL) {
610 		syslog(LOG_ERR, "<%s> %s not found", __func__,
611 		    cp->cp_ifname);
612 		return (1);
613 	}
614 
615 	if (ifi->ifi_persist == 1) {
616 		ifi->ifi_persist = 0;
617 		rm_ifinfo(ifi);
618 
619 		/* MC leaving needed here */
620 		sock_mc_leave(&sock, ifi->ifi_ifindex);
621 
622 		set_do_reload_ifname(ifi->ifi_ifname);
623 		set_do_reload(0);
624 	}
625 
626 	return (0);
627 }
628 
629 int
cm_handler_server(int fd)630 cm_handler_server(int fd)
631 {
632 	int state;
633 	char *msg;
634 	struct ctrl_msg_hdr *cm;
635 	struct ctrl_msg_pl cp;
636 	char buf[CM_MSG_MAXLEN];
637 	char pbuf[CM_MSG_MAXLEN];
638 	int error;
639 
640 	syslog(LOG_DEBUG, "<%s> enter", __func__);
641 
642 	memset(buf, 0, sizeof(buf));
643 	memset(pbuf, 0, sizeof(pbuf));
644 	cm = (struct ctrl_msg_hdr *)buf;
645 	msg = (char *)buf + sizeof(*cm);
646 
647 	state = CM_STATE_INIT;
648 	while (state != CM_STATE_EOM) {
649 		syslog(LOG_DEBUG, "<%s> state = %d", __func__, state);
650 
651 		switch (state) {
652 		case CM_STATE_INIT:
653 			state = CM_STATE_MSG_RECV;
654 			break;
655 		case CM_STATE_MSG_DISPATCH:
656 			cm->cm_version = CM_VERSION;
657 			error = cm_send(fd, buf);
658 			if (error)
659 				syslog(LOG_WARNING,
660 				    "<%s> cm_send()", __func__);
661 			state = CM_STATE_EOM;
662 			break;
663 		case CM_STATE_ACK_WAIT:
664 			error = cm_recv(fd, buf);
665 			if (error) {
666 				syslog(LOG_ERR,
667 				    "<%s> cm_recv()", __func__);
668 				close(fd);
669 				return (-1);
670 			}
671 
672 			switch (cm->cm_type) {
673 			case CM_TYPE_ACK:
674 				break;
675 			case CM_TYPE_ERR:
676 				syslog(LOG_DEBUG,
677 				    "<%s> CM_TYPE_ERR", __func__);
678 				close(fd);
679 				return (-1);
680 			default:
681 				syslog(LOG_DEBUG,
682 				    "<%s> unknown status", __func__);
683 				close(fd);
684 				return (-1);
685 			}
686 			state = CM_STATE_EOM;
687 			break;
688 		case CM_STATE_MSG_RECV:
689 			error = cm_recv(fd, buf);
690 
691 			if (error) {
692 				syslog(LOG_ERR,
693 				    "<%s> cm_recv()", __func__);
694 				close(fd);
695 				return (-1);
696 			}
697 			memset(&cp, 0, sizeof(cp));
698 
699 			syslog(LOG_DEBUG,
700 			    "<%s> cm->cm_type = %d", __func__, cm->cm_type);
701 			syslog(LOG_DEBUG,
702 			    "<%s> cm->cm_len = %zu", __func__, cm->cm_len);
703 
704 			switch (cm->cm_type) {
705 			case CM_TYPE_EOM:
706 				state = CM_STATE_EOM;
707 				/* FALLTHROUGH */
708 			case CM_TYPE_NUL:
709 				cm->cm_type = CM_TYPE_ACK;
710 				cm->cm_len = sizeof(*cm);
711 				break;
712 			case CM_TYPE_REQ_GET_PROP:
713 				cm_bin2pl(msg, &cp);
714 				error = cm_getprop(&cp);
715 				if (error) {
716 					cm->cm_type = CM_TYPE_ERR;
717 					cm->cm_len = sizeof(*cm);
718 				} else {
719 					cm->cm_type = CM_TYPE_ACK;
720 					cm->cm_len = sizeof(*cm);
721 					cm->cm_len += cm_pl2bin(msg, &cp);
722 				}
723 				if (cp.cp_val != NULL)
724 					free(cp.cp_val);
725 				break;
726 			case CM_TYPE_REQ_SET_PROP:
727 				cm_bin2pl(msg, &cp);
728 				error = cm_setprop(&cp);
729 				if (error) {
730 					cm->cm_type = CM_TYPE_ERR;
731 					cm->cm_len = sizeof(*cm);
732 				} else {
733 					cm->cm_type = CM_TYPE_ACK;
734 					cm->cm_len = sizeof(*cm);
735 				}
736 				break;
737 			default:
738 				cm->cm_type = CM_TYPE_ERR;
739 				cm->cm_len = sizeof(*cm);
740 			}
741 
742 			switch (cm->cm_type) {
743 			case CM_TYPE_ERR:
744 			case CM_TYPE_ACK:
745 				state = CM_STATE_MSG_DISPATCH;
746 				break;
747 			}
748 		}
749 	}
750 	syslog(LOG_DEBUG, "<%s> leave", __func__);
751 
752 	return (0);
753 }
754