usr.sbin/rtadvd/control_server.c

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