usr/src/cmd/svc/svcadm/svcadm.c

   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  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * Copyright 2015, Joyent, Inc. All rights reserved.
  28  */
  29
  30 /*
  31  * svcadm - request adminstrative actions for service instances
  32  */
  33
  34 #include <locale.h>
  35 #include <libintl.h>
  36 #include <libscf.h>
  37 #include <libscf_priv.h>
  38 #include <libcontract.h>
  39 #include <libcontract_priv.h>
  40 #include <sys/contract/process.h>
  41 #include <libuutil.h>
  42 #include <stddef.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47 #include <fcntl.h>
  48 #include <procfs.h>
  49 #include <assert.h>
  50 #include <errno.h>
  51 #include <zone.h>
  52
  53 #ifndef TEXT_DOMAIN
  54 #define TEXT_DOMAIN     "SUNW_OST_OSCMD"
  55 #endif /* TEXT_DOMAIN */
  56
  57 /* Must be a power of two */
  58 #define HT_BUCKETS      64
  59
  60 /*
  61  * Exit codes for enable and disable -s.
  62  */
  63 #define EXIT_SVC_FAILURE        3
  64 #define EXIT_DEP_FAILURE        4
  65
  66 #define WALK_FLAGS      (SCF_WALK_UNIPARTIAL | SCF_WALK_MULTIPLE)
  67
  68 /*
  69  * How long we will wait (in seconds) for a service to change state
  70  * before re-checking its dependencies.
  71  */
  72 #define WAIT_INTERVAL           3
  73
  74 #define bad_error(func, err)                                            \
  75         uu_panic("%s:%d: %s() failed with unexpected error %d.\n",      \
  76             __FILE__, __LINE__, (func), (err));
  77
  78 struct ht_elt {
  79         struct ht_elt   *next;
  80         boolean_t       active;
  81         char            str[1];
  82 };
  83
  84
  85 scf_handle_t *h;
  86 ssize_t max_scf_fmri_sz;
  87 static const char *emsg_permission_denied;
  88 static const char *emsg_nomem;
  89 static const char *emsg_create_pg_perm_denied;
  90 static const char *emsg_pg_perm_denied;
  91 static const char *emsg_prop_perm_denied;
  92 static const char *emsg_no_service;
  93
  94 static int exit_status = 0;
  95 static int verbose = 0;
  96 static char *scratch_fmri;
  97 static char *g_zonename = NULL;
  98 static char svcstate[80];
  99 static boolean_t svcsearch = B_FALSE;
 100
 101 static struct ht_elt **visited;
 102
 103 void do_scfdie(int lineno) __NORETURN;
 104 static void usage_milestone(void) __NORETURN;
 105 static void set_astring_prop(const char *, const char *, const char *,
 106     uint32_t, const char *, const char *);
 107 static void pr_warn(const char *format, ...);
 108
 109 /*
 110  * Visitors from synch.c, needed for enable -s and disable -s.
 111  */
 112 extern int is_enabled(scf_instance_t *);
 113 extern int has_potential(scf_instance_t *, int);
 114
 115 void
 116 do_scfdie(int lineno)
 117 {
 118         scf_error_t err;
 119
 120         switch (err = scf_error()) {
 121         case SCF_ERROR_CONNECTION_BROKEN:
 122                 uu_die(gettext("Connection to repository server broken.  "
 123                     "Exiting.\n"));
 124                 /* NOTREACHED */
 125
 126         case SCF_ERROR_BACKEND_READONLY:
 127                 uu_die(gettext("Repository is read-only.  Exiting.\n"));
 128                 /* NOTREACHED */
 129
 130         default:
 131 #ifdef NDEBUG
 132                 uu_die(gettext("Unexpected libscf error: %s.  Exiting.\n"),
 133                     scf_strerror(err));
 134 #else
 135                 uu_die("Unexpected libscf error on line %d: %s.\n", lineno,
 136                     scf_strerror(err));
 137 #endif
 138         }
 139 }
 140
 141 #define scfdie()        do_scfdie(__LINE__)
 142
 143 static void
 144 usage()
 145 {
 146         (void) fprintf(stderr, gettext(
 147         "Usage: %1$s [-S <state>] [-v] [-Z | -z zone] [cmd [args ... ]]\n\n"
 148         "\t%1$s enable [-rst] [<service> ...]\t- enable and online service(s)\n"
 149         "\t%1$s disable [-st] [<service> ...]\t- disable and offline "
 150         "service(s)\n"
 151         "\t%1$s restart [-d] [<service> ...]\t- restart specified service(s)\n"
 152         "\t%1$s refresh [<service> ...]\t\t- re-read service configuration\n"
 153         "\t%1$s mark [-It] <state> [<service> ...] - set maintenance state\n"
 154         "\t%1$s clear [<service> ...]\t\t- clear maintenance state\n"
 155         "\t%1$s milestone [-d] <milestone>\t- advance to a service milestone\n"
 156         "\n\t"
 157         "Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n"
 158         "\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n"
 159         "\n"
 160         "\t%1$s <cmd> svc:/network/smtp:sendmail\n"
 161         "\t%1$s <cmd> network/smtp:sendmail\n"
 162         "\t%1$s <cmd> network/*mail\n"
 163         "\t%1$s <cmd> network/smtp\n"
 164         "\t%1$s <cmd> smtp:sendmail\n"
 165         "\t%1$s <cmd> smtp\n"
 166         "\t%1$s <cmd> sendmail\n"), uu_getpname());
 167
 168         exit(UU_EXIT_USAGE);
 169 }
 170
 171
 172 /*
 173  * FMRI hash table for recursive enable.
 174  */
 175
 176 static uint32_t
 177 hash_fmri(const char *str)
 178 {
 179         uint32_t h = 0, g;
 180         const char *p;
 181
 182         /* Generic hash function from uts/common/os/modhash.c . */
 183         for (p = str; *p != '\0'; ++p) {
 184                 h = (h << 4) + *p;
 185                 if ((g = (h & 0xf0000000)) != 0) {
 186                         h ^= (g >> 24);
 187                         h ^= g;
 188                 }
 189         }
 190
 191         return (h);
 192 }
 193
 194 /*
 195  * Return 1 if str has been visited, 0 if it has not, and -1 if memory could not
 196  * be allocated.
 197  */
 198 static int
 199 visited_find_or_add(const char *str, struct ht_elt **hep)
 200 {
 201         uint32_t h;
 202         uint_t i;
 203         struct ht_elt *he;
 204
 205         h = hash_fmri(str);
 206         i = h & (HT_BUCKETS - 1);
 207
 208         for (he = visited[i]; he != NULL; he = he->next) {
 209                 if (strcmp(he->str, str) == 0) {
 210                         if (hep)
 211                                 *hep = he;
 212                         return (1);
 213                 }
 214         }
 215
 216         he = malloc(offsetof(struct ht_elt, str) + strlen(str) + 1);
 217         if (he == NULL)
 218                 return (-1);
 219
 220         (void) strcpy(he->str, str);
 221
 222         he->next = visited[i];
 223         visited[i] = he;
 224
 225         if (hep)
 226                 *hep = he;
 227         return (0);
 228 }
 229
 230
 231 /*
 232  * Returns 0, ECANCELED if pg is deleted, ENOENT if propname doesn't exist,
 233  * EINVAL if the property is not of boolean type or has no values, and E2BIG
 234  * if it has more than one value.  *bp is set if 0 or E2BIG is returned.
 235  */
 236 int
 237 get_bool_prop(scf_propertygroup_t *pg, const char *propname, uint8_t *bp)
 238 {
 239         scf_property_t *prop;
 240         scf_value_t *val;
 241         int ret;
 242
 243         if ((prop = scf_property_create(h)) == NULL ||
 244             (val = scf_value_create(h)) == NULL)
 245                 scfdie();
 246
 247         if (scf_pg_get_property(pg, propname, prop) != 0) {
 248                 switch (scf_error()) {
 249                 case SCF_ERROR_DELETED:
 250                         ret = ECANCELED;
 251                         goto out;
 252
 253                 case SCF_ERROR_NOT_FOUND:
 254                         ret = ENOENT;
 255                         goto out;
 256
 257                 case SCF_ERROR_NOT_SET:
 258                         assert(0);
 259                         abort();
 260                         /* NOTREACHED */
 261
 262                 default:
 263                         scfdie();
 264                 }
 265         }
 266
 267         if (scf_property_get_value(prop, val) == 0) {
 268                 ret = 0;
 269         } else {
 270                 switch (scf_error()) {
 271                 case SCF_ERROR_DELETED:
 272                         ret = ENOENT;
 273                         goto out;
 274
 275                 case SCF_ERROR_NOT_FOUND:
 276                         ret = EINVAL;
 277                         goto out;
 278
 279                 case SCF_ERROR_CONSTRAINT_VIOLATED:
 280                         ret = E2BIG;
 281                         break;
 282
 283                 case SCF_ERROR_NOT_SET:
 284                         assert(0);
 285                         abort();
 286                         /* NOTREACHED */
 287
 288                 default:
 289                         scfdie();
 290                 }
 291         }
 292
 293         if (scf_value_get_boolean(val, bp) != 0) {
 294                 if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
 295                         scfdie();
 296
 297                 ret = EINVAL;
 298                 goto out;
 299         }
 300
 301 out:
 302         scf_value_destroy(val);
 303         scf_property_destroy(prop);
 304         return (ret);
 305 }
 306
 307 /*
 308  * Returns 0, EPERM, or EROFS.
 309  */
 310 static int
 311 set_bool_prop(scf_propertygroup_t *pg, const char *propname, boolean_t b)
 312 {
 313         scf_value_t *v;
 314         scf_transaction_t *tx;
 315         scf_transaction_entry_t *ent;
 316         int ret = 0, r;
 317
 318         if ((tx = scf_transaction_create(h)) == NULL ||
 319             (ent = scf_entry_create(h)) == NULL ||
 320             (v = scf_value_create(h)) == NULL)
 321                 scfdie();
 322
 323         scf_value_set_boolean(v, b);
 324
 325         for (;;) {
 326                 if (scf_transaction_start(tx, pg) == -1) {
 327                         switch (scf_error()) {
 328                         case SCF_ERROR_PERMISSION_DENIED:
 329                                 ret = EPERM;
 330                                 goto out;
 331
 332                         case SCF_ERROR_BACKEND_READONLY:
 333                                 ret = EROFS;
 334                                 goto out;
 335
 336                         default:
 337                                 scfdie();
 338                         }
 339                 }
 340
 341                 if (scf_transaction_property_change_type(tx, ent, propname,
 342                     SCF_TYPE_BOOLEAN) != 0) {
 343                         if (scf_error() != SCF_ERROR_NOT_FOUND)
 344                                 scfdie();
 345
 346                         if (scf_transaction_property_new(tx, ent, propname,
 347                             SCF_TYPE_BOOLEAN) != 0)
 348                                 scfdie();
 349                 }
 350
 351                 r = scf_entry_add_value(ent, v);
 352                 assert(r == 0);
 353
 354                 r = scf_transaction_commit(tx);
 355                 if (r == 1)
 356                         break;
 357
 358                 scf_transaction_reset(tx);
 359
 360                 if (r != 0) {
 361                         switch (scf_error()) {
 362                         case SCF_ERROR_PERMISSION_DENIED:
 363                                 ret = EPERM;
 364                                 goto out;
 365
 366                         case SCF_ERROR_BACKEND_READONLY:
 367                                 ret = EROFS;
 368                                 goto out;
 369
 370                         default:
 371                                 scfdie();
 372                         }
 373                 }
 374
 375                 if (scf_pg_update(pg) == -1)
 376                         scfdie();
 377         }
 378
 379 out:
 380         scf_transaction_destroy(tx);
 381         scf_entry_destroy(ent);
 382         scf_value_destroy(v);
 383         return (ret);
 384 }
 385
 386 /*
 387  * Gets the single astring value of the propname property of pg.  prop & v are
 388  * scratch space.  Returns the length of the string on success or
 389  *   -ENOENT - pg has no property named propname
 390  *   -E2BIG - property has no values or multiple values
 391  *   -EINVAL - property type is not compatible with astring
 392  */
 393 ssize_t
 394 get_astring_prop(const scf_propertygroup_t *pg, const char *propname,
 395     scf_property_t *prop, scf_value_t *v, char *buf, size_t bufsz)
 396 {
 397         ssize_t sz;
 398
 399         if (scf_pg_get_property(pg, propname, prop) != 0) {
 400                 if (scf_error() != SCF_ERROR_NOT_FOUND)
 401                         scfdie();
 402
 403                 return (-ENOENT);
 404         }
 405
 406         if (scf_property_get_value(prop, v) != 0) {
 407                 switch (scf_error()) {
 408                 case SCF_ERROR_NOT_FOUND:
 409                 case SCF_ERROR_CONSTRAINT_VIOLATED:
 410                         return (-E2BIG);
 411
 412                 default:
 413                         scfdie();
 414                 }
 415         }
 416
 417         sz = scf_value_get_astring(v, buf, bufsz);
 418         if (sz < 0) {
 419                 if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
 420                         scfdie();
 421
 422                 return (-EINVAL);
 423         }
 424
 425         return (sz);
 426 }
 427
 428 /*
 429  * Returns 0 or EPERM.
 430  */
 431 static int
 432 pg_get_or_add(const scf_instance_t *inst, const char *pgname,
 433     const char *pgtype, uint32_t pgflags, scf_propertygroup_t *pg)
 434 {
 435 again:
 436         if (scf_instance_get_pg(inst, pgname, pg) == 0)
 437                 return (0);
 438
 439         if (scf_error() != SCF_ERROR_NOT_FOUND)
 440                 scfdie();
 441
 442         if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) == 0)
 443                 return (0);
 444
 445         switch (scf_error()) {
 446         case SCF_ERROR_EXISTS:
 447                 goto again;
 448
 449         case SCF_ERROR_PERMISSION_DENIED:
 450                 return (EPERM);
 451
 452         default:
 453                 scfdie();
 454                 /* NOTREACHED */
 455         }
 456 }
 457
 458 static int
 459 my_ct_name(char *out, size_t len)
 460 {
 461         ct_stathdl_t st;
 462         char *ct_fmri;
 463         ctid_t ct;
 464         int fd, errno, ret;
 465
 466         if ((ct = getctid()) == -1)
 467                 uu_die(gettext("Could not get contract id for process"));
 468
 469         fd = contract_open(ct, "process", "status", O_RDONLY);
 470
 471         if ((errno = ct_status_read(fd, CTD_ALL, &st)) != 0)
 472                 uu_warn(gettext("Could not read status of contract "
 473                     "%ld: %s.\n"), ct, strerror(errno));
 474
 475         if ((errno = ct_pr_status_get_svc_fmri(st, &ct_fmri)) != 0)
 476                 uu_warn(gettext("Could not get svc_fmri for contract "
 477                     "%ld: %s.\n"), ct, strerror(errno));
 478
 479         ret = strlcpy(out, ct_fmri, len);
 480
 481         ct_status_free(st);
 482         (void) close(fd);
 483
 484         return (ret);
 485 }
 486
 487 /*
 488  * Set auxiliary_tty and auxiliary_fmri properties in restarter_actions pg to
 489  * communicate whether the action is requested from a tty and the fmri of the
 490  * responsible process.
 491  *
 492  * Returns 0, EPERM, or EROFS
 493  */
 494 static int
 495 restarter_setup(const char *fmri, const scf_instance_t *inst)
 496 {
 497         boolean_t b = B_FALSE;
 498         scf_propertygroup_t *pg = NULL;
 499         int ret = 0;
 500
 501         if ((pg = scf_pg_create(h)) == NULL)
 502                 scfdie();
 503
 504         if (pg_get_or_add(inst, SCF_PG_RESTARTER_ACTIONS,
 505             SCF_PG_RESTARTER_ACTIONS_TYPE, SCF_PG_RESTARTER_ACTIONS_FLAGS,
 506             pg) == EPERM) {
 507                 if (!verbose)
 508                         uu_warn(emsg_permission_denied, fmri);
 509                 else
 510                         uu_warn(emsg_create_pg_perm_denied, fmri,
 511                             SCF_PG_RESTARTER_ACTIONS);
 512
 513                 ret = EPERM;
 514                 goto out;
 515         }
 516
 517         /* Set auxiliary_tty property */
 518         if (isatty(STDIN_FILENO))
 519                 b = B_TRUE;
 520
 521         /* Create and set state to disabled */
 522         switch (set_bool_prop(pg, SCF_PROPERTY_AUX_TTY, b)) {
 523         case 0:
 524                 break;
 525
 526         case EPERM:
 527                 if (!verbose)
 528                         uu_warn(emsg_permission_denied, fmri);
 529                 else
 530                         uu_warn(emsg_prop_perm_denied, fmri,
 531                             SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY);
 532
 533                 ret = EPERM;
 534                 goto out;
 535                 /* NOTREACHED */
 536
 537         case EROFS:
 538                 /* Shouldn't happen, but it can. */
 539                 if (!verbose)
 540                         uu_warn(gettext("%s: Repository read-only.\n"), fmri);
 541                 else
 542                         uu_warn(gettext("%s: Could not set %s/%s "
 543                             "(repository read-only).\n"), fmri,
 544                             SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY);
 545
 546                 ret = EROFS;
 547                 goto out;
 548                 /* NOTREACHED */
 549
 550         default:
 551                 scfdie();
 552         }
 553
 554         if (my_ct_name(scratch_fmri, max_scf_fmri_sz) > 0) {
 555                 set_astring_prop(fmri, SCF_PG_RESTARTER_ACTIONS,
 556                     SCF_PG_RESTARTER_ACTIONS_TYPE,
 557                     SCF_PG_RESTARTER_ACTIONS_FLAGS,
 558                     SCF_PROPERTY_AUX_FMRI, scratch_fmri);
 559         } else {
 560                 uu_warn(gettext("%s: Could not set %s/%s: "
 561                     "my_ct_name failed.\n"), fmri,
 562                     SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_FMRI);
 563         }
 564
 565 out:
 566         scf_pg_destroy(pg);
 567         return (ret);
 568 }
 569
 570 /*
 571  * Enable or disable inst, per enable.  If temp is true, set
 572  * general_ovr/enabled.  Otherwise set general/enabled and delete
 573  * general_ovr/enabled if it exists (order is important here: we don't want the
 574  * enabled status to glitch).
 575  */
 576 static void
 577 set_inst_enabled(const char *fmri, scf_instance_t *inst, boolean_t temp,
 578     boolean_t enable)
 579 {
 580         scf_propertygroup_t *pg;
 581         uint8_t b;
 582         const char *pgname = NULL;      /* For emsg_pg_perm_denied */
 583         int r;
 584
 585         pg = scf_pg_create(h);
 586         if (pg == NULL)
 587                 scfdie();
 588
 589         if (restarter_setup(fmri, inst))
 590                 goto out;
 591
 592         /*
 593          * An instance's configuration is incomplete if general/enabled
 594          * doesn't exist. Create both the property group and property
 595          * here if they don't exist.
 596          */
 597         pgname = SCF_PG_GENERAL;
 598         if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE,
 599             SCF_PG_GENERAL_FLAGS, pg) != 0)
 600                 goto eperm;
 601
 602         if (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b) != 0) {
 603                 /* Create and set state to disabled */
 604                 switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, B_FALSE)) {
 605                 case 0:
 606                         break;
 607
 608                 case EPERM:
 609                         goto eperm;
 610
 611                 case EROFS:
 612                         /* Shouldn't happen, but it can. */
 613                         if (!verbose)
 614                                 uu_warn(gettext("%s: Repository read-only.\n"),
 615                                     fmri);
 616                         else
 617                                 uu_warn(gettext("%s: Could not set %s/%s "
 618                                     "(repository read-only).\n"), fmri,
 619                                     SCF_PG_GENERAL, SCF_PROPERTY_ENABLED);
 620                         goto out;
 621
 622                 default:
 623                         assert(0);
 624                         abort();
 625                 }
 626         }
 627
 628         if (temp) {
 629                 /* Set general_ovr/enabled */
 630                 pgname = SCF_PG_GENERAL_OVR;
 631                 if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_OVR_TYPE,
 632                     SCF_PG_GENERAL_OVR_FLAGS, pg) != 0)
 633                         goto eperm;
 634
 635                 switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) {
 636                 case 0:
 637                         break;
 638
 639                 case EPERM:
 640                         goto eperm;
 641
 642                 case EROFS:
 643                         /* Shouldn't happen, but it can. */
 644                         if (!verbose)
 645                                 uu_warn(gettext("%s: Repository read-only.\n"),
 646                                     fmri);
 647                         else
 648                                 uu_warn(gettext("%s: Could not set %s/%s "
 649                                     "(repository read-only).\n"), fmri,
 650                                     SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED);
 651                         goto out;
 652
 653                 default:
 654                         assert(0);
 655                         abort();
 656                 }
 657
 658                 if (verbose)
 659                         (void) printf(enable ?
 660                             gettext("%s temporarily enabled.\n") :
 661                             gettext("%s temporarily disabled.\n"), fmri);
 662         } else {
 663 again:
 664                 /*
 665                  * Both pg and property should exist since we created
 666                  * them earlier. However, there's still a chance that
 667                  * someone may have deleted the property out from under
 668                  * us.
 669                  */
 670                 if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE,
 671                     SCF_PG_GENERAL_FLAGS, pg) != 0)
 672                         goto eperm;
 673
 674                 switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) {
 675                 case 0:
 676                         break;
 677
 678                 case EPERM:
 679                         goto eperm;
 680
 681                 case EROFS:
 682                         /*
 683                          * If general/enabled is already set the way we want,
 684                          * proceed.
 685                          */
 686                         switch (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b)) {
 687                         case 0:
 688                                 if ((b != 0) == (enable != B_FALSE))
 689                                         break;
 690                                 /* FALLTHROUGH */
 691
 692                         case ENOENT:
 693                         case EINVAL:
 694                         case E2BIG:
 695                                 if (!verbose)
 696                                         uu_warn(gettext("%s: Repository "
 697                                             "read-only.\n"), fmri);
 698                                 else
 699                                         uu_warn(gettext("%s: Could not set "
 700                                             "%s/%s (repository read-only).\n"),
 701                                             fmri, SCF_PG_GENERAL,
 702                                             SCF_PROPERTY_ENABLED);
 703                                 goto out;
 704
 705                         case ECANCELED:
 706                                 goto again;
 707
 708                         default:
 709                                 assert(0);
 710                                 abort();
 711                         }
 712                         break;
 713
 714                 default:
 715                         assert(0);
 716                         abort();
 717                 }
 718
 719                 pgname = SCF_PG_GENERAL_OVR;
 720                 r = scf_instance_delete_prop(inst, pgname,
 721                     SCF_PROPERTY_ENABLED);
 722                 switch (r) {
 723                 case 0:
 724                         break;
 725
 726                 case ECANCELED:
 727                         uu_warn(emsg_no_service, fmri);
 728                         goto out;
 729
 730                 case EPERM:
 731                         goto eperm;
 732
 733                 case EACCES:
 734                         uu_warn(gettext("Could not delete %s/%s "
 735                             "property of %s: backend access denied.\n"),
 736                             pgname, SCF_PROPERTY_ENABLED, fmri);
 737                         goto out;
 738
 739                 case EROFS:
 740                         uu_warn(gettext("Could not delete %s/%s "
 741                             "property of %s: backend is read-only.\n"),
 742                             pgname, SCF_PROPERTY_ENABLED, fmri);
 743                         goto out;
 744
 745                 default:
 746                         bad_error("scf_instance_delete_prop", r);
 747                 }
 748
 749                 if (verbose)
 750                         (void) printf(enable ?  gettext("%s enabled.\n") :
 751                             gettext("%s disabled.\n"), fmri);
 752         }
 753
 754         scf_pg_destroy(pg);
 755         return;
 756
 757 eperm:
 758         assert(pgname != NULL);
 759         if (!verbose)
 760                 uu_warn(emsg_permission_denied, fmri);
 761         else
 762                 uu_warn(emsg_pg_perm_denied, fmri, pgname);
 763
 764 out:
 765         scf_pg_destroy(pg);
 766         exit_status = 1;
 767 }
 768
 769 /*
 770  * Set inst to the instance which corresponds to fmri.  If fmri identifies
 771  * a service with a single instance, get that instance.
 772  *
 773  * Fails with
 774  *   ENOTSUP - fmri has an unsupported scheme
 775  *   EINVAL - fmri is invalid
 776  *   ENOTDIR - fmri does not identify a service or instance
 777  *   ENOENT - could not locate instance
 778  *   E2BIG - fmri is a service with multiple instances (warning not printed)
 779  */
 780 static int
 781 get_inst_mult(const char *fmri, scf_instance_t *inst)
 782 {
 783         char *cfmri;
 784         const char *svc_name, *inst_name, *pg_name;
 785         scf_service_t *svc;
 786         scf_instance_t *inst2;
 787         scf_iter_t *iter;
 788         int ret;
 789
 790         if (strncmp(fmri, "lrc:", sizeof ("lrc:") - 1) == 0) {
 791                 uu_warn(gettext("FMRI \"%s\" is a legacy service.\n"), fmri);
 792                 exit_status = 1;
 793                 return (ENOTSUP);
 794         }
 795
 796         cfmri = strdup(fmri);
 797         if (cfmri == NULL)
 798                 uu_die(emsg_nomem);
 799
 800         if (scf_parse_svc_fmri(cfmri, NULL, &svc_name, &inst_name, &pg_name,
 801             NULL) != SCF_SUCCESS) {
 802                 free(cfmri);
 803                 uu_warn(gettext("FMRI \"%s\" is invalid.\n"), fmri);
 804                 exit_status = 1;
 805                 return (EINVAL);
 806         }
 807
 808         free(cfmri);
 809
 810         if (svc_name == NULL || pg_name != NULL) {
 811                 uu_warn(gettext(
 812                     "FMRI \"%s\" does not designate a service or instance.\n"),
 813                     fmri);
 814                 exit_status = 1;
 815                 return (ENOTDIR);
 816         }
 817
 818         if (inst_name != NULL) {
 819                 if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
 820                     NULL, SCF_DECODE_FMRI_EXACT) == 0)
 821                         return (0);
 822
 823                 if (scf_error() != SCF_ERROR_NOT_FOUND)
 824                         scfdie();
 825
 826                 uu_warn(gettext("No such instance \"%s\".\n"), fmri);
 827                 exit_status = 1;
 828
 829                 return (ENOENT);
 830         }
 831
 832         if ((svc = scf_service_create(h)) == NULL ||
 833             (inst2 = scf_instance_create(h)) == NULL ||
 834             (iter = scf_iter_create(h)) == NULL)
 835                 scfdie();
 836
 837         if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL,
 838             SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) {
 839                 if (scf_error() != SCF_ERROR_NOT_FOUND)
 840                         scfdie();
 841
 842                 uu_warn(emsg_no_service, fmri);
 843                 exit_status = 1;
 844
 845                 ret = ENOENT;
 846                 goto out;
 847         }
 848
 849         /* If the service has only one child, use it. */
 850         if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS)
 851                 scfdie();
 852
 853         ret = scf_iter_next_instance(iter, inst);
 854         if (ret < 0)
 855                 scfdie();
 856         if (ret != 1) {
 857                 uu_warn(gettext("Service \"%s\" has no instances.\n"),
 858                     fmri);
 859                 exit_status = 1;
 860                 ret = ENOENT;
 861                 goto out;
 862         }
 863
 864         ret = scf_iter_next_instance(iter, inst2);
 865         if (ret < 0)
 866                 scfdie();
 867
 868         if (ret != 0) {
 869                 ret = E2BIG;
 870                 goto out;
 871         }
 872
 873         ret = 0;
 874
 875 out:
 876         scf_iter_destroy(iter);
 877         scf_instance_destroy(inst2);
 878         scf_service_destroy(svc);
 879         return (ret);
 880 }
 881
 882 /*
 883  * Same as get_inst_mult(), but on E2BIG prints a warning and returns ENOENT.
 884  */
 885 static int
 886 get_inst(const char *fmri, scf_instance_t *inst)
 887 {
 888         int r;
 889
 890         r = get_inst_mult(fmri, inst);
 891         if (r != E2BIG)
 892                 return (r);
 893
 894         uu_warn(gettext("operation on service %s is ambiguous; "
 895             "instance specification needed.\n"), fmri);
 896         return (ENOENT);
 897 }
 898
 899 static char *
 900 inst_get_fmri(const scf_instance_t *inst)
 901 {
 902         ssize_t sz;
 903
 904         sz = scf_instance_to_fmri(inst, scratch_fmri, max_scf_fmri_sz);
 905         if (sz < 0)
 906                 scfdie();
 907         if (sz >= max_scf_fmri_sz)
 908                 uu_die(gettext("scf_instance_to_fmri() returned unexpectedly "
 909                     "long value.\n"));
 910
 911         return (scratch_fmri);
 912 }
 913
 914 static ssize_t
 915 dep_get_astring(const char *fmri, const char *pgname,
 916     const scf_propertygroup_t *pg, const char *propname, scf_property_t *prop,
 917     scf_value_t *v, char *buf, size_t bufsz)
 918 {
 919         ssize_t sz;
 920
 921         sz = get_astring_prop(pg, propname, prop, v, buf, bufsz);
 922         if (sz >= 0)
 923                 return (sz);
 924
 925         switch (-sz) {
 926         case ENOENT:
 927                 uu_warn(gettext("\"%s\" is misconfigured (\"%s\" dependency "
 928                     "lacks \"%s\" property.)\n"), fmri, pgname, propname);
 929                 return (-1);
 930
 931         case E2BIG:
 932                 uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property "
 933                     "is not single-valued.)\n"), fmri, pgname, propname);
 934                 return (-1);
 935
 936         case EINVAL:
 937                 uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property "
 938                     "is not of astring type.)\n"), fmri, pgname, propname);
 939                 return (-1);
 940
 941         default:
 942                 assert(0);
 943                 abort();
 944                 /* NOTREACHED */
 945         }
 946 }
 947
 948 static boolean_t
 949 multiple_instances(scf_iter_t *iter, scf_value_t *v, char *buf)
 950 {
 951         int count = 0, r;
 952         boolean_t ret;
 953         scf_instance_t *inst;
 954
 955         inst = scf_instance_create(h);
 956         if (inst == NULL)
 957                 scfdie();
 958
 959         for (;;) {
 960                 r = scf_iter_next_value(iter, v);
 961                 if (r == 0) {
 962                         ret = B_FALSE;
 963                         goto out;
 964                 }
 965                 if (r != 1)
 966                         scfdie();
 967
 968                 if (scf_value_get_astring(v, buf, max_scf_fmri_sz) < 0)
 969                         scfdie();
 970
 971                 switch (get_inst_mult(buf, inst)) {
 972                 case 0:
 973                         ++count;
 974                         if (count > 1) {
 975                                 ret = B_TRUE;
 976                                 goto out;
 977                         }
 978                         break;
 979
 980                 case ENOTSUP:
 981                 case EINVAL:
 982                 case ENOTDIR:
 983                 case ENOENT:
 984                         continue;
 985
 986                 case E2BIG:
 987                         ret = B_TRUE;
 988                         goto out;
 989
 990                 default:
 991                         assert(0);
 992                         abort();
 993                 }
 994         }
 995
 996 out:
 997         scf_instance_destroy(inst);
 998         return (ret);
 999 }
1000
1001 /*
1002  * Enable the service or instance identified by fmri and its dependencies,
1003  * recursively.  Specifically, call get_inst(fmri), enable the result, and
1004  * recurse on its restarter and the dependencies.  To avoid duplication of
1005  * effort or looping around a dependency cycle, each FMRI is entered into the
1006  * "visited" hash table.  While recursing, the hash table entry is marked
1007  * "active", so that if we come upon it again, we know we've hit a cycle.
1008  * exclude_all and optional_all dependencies are ignored.  require_any
1009  * dependencies are followed only if they comprise a single service; otherwise
1010  * the user is warned.
1011  *
1012  * fmri must point to a writable max_scf_fmri_sz buffer.  Returns EINVAL if fmri
1013  * is invalid, E2BIG if fmri identifies a service with multiple instances, ELOOP
1014  * on cycle detection, or 0 on success.
1015  */
1016 static int
1017 enable_fmri_rec(char *fmri, boolean_t temp)
1018 {
1019         scf_instance_t *inst;
1020         scf_snapshot_t *snap;
1021         scf_propertygroup_t *pg;
1022         scf_property_t *prop;
1023         scf_value_t *v;
1024         scf_iter_t *pg_iter, *val_iter;
1025         scf_type_t ty;
1026         char *buf, *pgname;
1027         ssize_t name_sz, len, sz;
1028         int ret;
1029         struct ht_elt *he;
1030
1031         len = scf_canonify_fmri(fmri, fmri, max_scf_fmri_sz);
1032         if (len < 0) {
1033                 assert(scf_error() == SCF_ERROR_INVALID_ARGUMENT);
1034                 return (EINVAL);
1035         }
1036         assert(len < max_scf_fmri_sz);
1037
1038         switch (visited_find_or_add(fmri, &he)) {
1039         case 0:
1040                 he->active = B_TRUE;
1041                 break;
1042
1043         case 1:
1044                 return (he->active ? ELOOP : 0);
1045
1046         case -1:
1047                 uu_die(emsg_nomem);
1048
1049         default:
1050                 assert(0);
1051                 abort();
1052         }
1053
1054         inst = scf_instance_create(h);
1055         if (inst == NULL)
1056                 scfdie();
1057
1058         switch (get_inst_mult(fmri, inst)) {
1059         case 0:
1060                 break;
1061
1062         case E2BIG:
1063                 he->active = B_FALSE;
1064                 return (E2BIG);
1065
1066         default:
1067                 he->active = B_FALSE;
1068                 return (0);
1069         }
1070
1071         set_inst_enabled(fmri, inst, temp, B_TRUE);
1072
1073         if ((snap = scf_snapshot_create(h)) == NULL ||
1074             (pg = scf_pg_create(h)) == NULL ||
1075             (prop = scf_property_create(h)) == NULL ||
1076             (v = scf_value_create(h)) == NULL ||
1077             (pg_iter = scf_iter_create(h)) == NULL ||
1078             (val_iter = scf_iter_create(h)) == NULL)
1079                 scfdie();
1080
1081         buf = malloc(max_scf_fmri_sz);
1082         if (buf == NULL)
1083                 uu_die(emsg_nomem);
1084
1085         name_sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
1086         if (name_sz < 0)
1087                 scfdie();
1088         ++name_sz;
1089         pgname = malloc(name_sz);
1090         if (pgname == NULL)
1091                 uu_die(emsg_nomem);
1092
1093         if (scf_instance_get_snapshot(inst, "running", snap) != 0) {
1094                 if (scf_error() != SCF_ERROR_NOT_FOUND)
1095                         scfdie();
1096
1097                 scf_snapshot_destroy(snap);
1098                 snap = NULL;
1099         }
1100
1101         /* Enable restarter */
1102         if (scf_instance_get_pg_composed(inst, snap, SCF_PG_GENERAL, pg) != 0) {
1103                 if (scf_error() != SCF_ERROR_NOT_FOUND)
1104                         scfdie();
1105
1106                 uu_warn(gettext("\"%s\" is misconfigured (lacks \"%s\" "
1107                     "property group).\n"), fmri, SCF_PG_GENERAL);
1108                 ret = 0;
1109                 goto out;
1110         }
1111
1112         sz = get_astring_prop(pg, SCF_PROPERTY_RESTARTER, prop, v, buf,
1113             max_scf_fmri_sz);
1114         if (sz > max_scf_fmri_sz) {
1115                 uu_warn(gettext("\"%s\" is misconfigured (the value of "
1116                     "\"%s/%s\" is too long).\n"), fmri, SCF_PG_GENERAL,
1117                     SCF_PROPERTY_RESTARTER);
1118                 ret = 0;
1119                 goto out;
1120         } else if (sz >= 0) {
1121                 switch (enable_fmri_rec(buf, temp)) {
1122                 case 0:
1123                         break;
1124
1125                 case EINVAL:
1126                         uu_warn(gettext("Restarter FMRI for \"%s\" is "
1127                             "invalid.\n"), fmri);
1128                         break;
1129
1130                 case E2BIG:
1131                         uu_warn(gettext("Restarter FMRI for \"%s\" identifies "
1132                             "a service with multiple instances.\n"), fmri);
1133                         break;
1134
1135                 case ELOOP:
1136                         ret = ELOOP;
1137                         goto out;
1138
1139                 default:
1140                         assert(0);
1141                         abort();
1142                 }
1143         } else if (sz < 0) {
1144                 switch (-sz) {
1145                 case ENOENT:
1146                         break;
1147
1148                 case E2BIG:
1149                         uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" "
1150                             "property is not single-valued).\n"), fmri,
1151                             SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER);
1152                         ret = 0;
1153                         goto out;
1154
1155                 case EINVAL:
1156                         uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" "
1157                             "property is not of astring type).\n"), fmri,
1158                             SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER);
1159                         ret = 0;
1160                         goto out;
1161
1162                 default:
1163                         assert(0);
1164                         abort();
1165                 }
1166         }
1167
1168         if (scf_iter_instance_pgs_typed_composed(pg_iter, inst, snap,
1169             SCF_GROUP_DEPENDENCY) == -1)
1170                 scfdie();
1171
1172         while (scf_iter_next_pg(pg_iter, pg) > 0) {
1173                 len = scf_pg_get_name(pg, pgname, name_sz);
1174                 if (len < 0)
1175                         scfdie();
1176                 assert(len < name_sz);
1177
1178                 if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_TYPE, prop,
1179                     v, buf, max_scf_fmri_sz) < 0)
1180                         continue;
1181
1182                 if (strcmp(buf, "service") != 0)
1183                         continue;
1184
1185                 if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_GROUPING,
1186                     prop, v, buf, max_scf_fmri_sz) < 0)
1187                         continue;
1188
1189                 if (strcmp(buf, SCF_DEP_EXCLUDE_ALL) == 0 ||
1190                     strcmp(buf, SCF_DEP_OPTIONAL_ALL) == 0)
1191                         continue;
1192
1193                 if (strcmp(buf, SCF_DEP_REQUIRE_ALL) != 0 &&
1194                     strcmp(buf, SCF_DEP_REQUIRE_ANY) != 0) {
1195                         uu_warn(gettext("Dependency \"%s\" of \"%s\" has "
1196                             "unknown type \"%s\".\n"), pgname, fmri, buf);
1197                         continue;
1198                 }
1199
1200                 if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) ==
1201                     -1) {
1202                         if (scf_error() != SCF_ERROR_NOT_FOUND)
1203                                 scfdie();
1204
1205                         uu_warn(gettext("\"%s\" is misconfigured (\"%s\" "
1206                             "dependency lacks \"%s\" property.)\n"), fmri,
1207                             pgname, SCF_PROPERTY_ENTITIES);
1208                         continue;
1209                 }
1210
1211                 if (scf_property_type(prop, &ty) != SCF_SUCCESS)
1212                         scfdie();
1213
1214                 if (ty != SCF_TYPE_FMRI) {
1215                         uu_warn(gettext("\"%s\" is misconfigured (property "
1216                             "\"%s/%s\" is not of fmri type).\n"), fmri, pgname,
1217                             SCF_PROPERTY_ENTITIES);
1218                         continue;
1219                 }
1220
1221                 if (scf_iter_property_values(val_iter, prop) == -1)
1222                         scfdie();
1223
1224                 if (strcmp(buf, SCF_DEP_REQUIRE_ANY) == 0) {
1225                         if (multiple_instances(val_iter, v, buf)) {
1226                                 (void) printf(gettext("%s requires one of:\n"),
1227                                     fmri);
1228
1229                                 if (scf_iter_property_values(val_iter, prop) !=
1230                                     0)
1231                                         scfdie();
1232
1233                                 for (;;) {
1234                                         int r;
1235
1236                                         r = scf_iter_next_value(val_iter, v);
1237                                         if (r == 0)
1238                                                 break;
1239                                         if (r != 1)
1240                                                 scfdie();
1241
1242                                         if (scf_value_get_astring(v, buf,
1243                                             max_scf_fmri_sz) < 0)
1244                                                 scfdie();
1245
1246                                         (void) fputs("  ", stdout);
1247                                         (void) puts(buf);
1248                                 }
1249
1250                                 continue;
1251                         }
1252
1253                         /*
1254                          * Since there's only one instance, we can enable it.
1255                          * Reset val_iter and continue.
1256                          */
1257                         if (scf_iter_property_values(val_iter, prop) != 0)
1258                                 scfdie();
1259                 }
1260
1261                 for (;;) {
1262                         ret = scf_iter_next_value(val_iter, v);
1263                         if (ret == 0)
1264                                 break;
1265                         if (ret != 1)
1266                                 scfdie();
1267
1268                         if (scf_value_get_astring(v, buf, max_scf_fmri_sz) ==
1269                             -1)
1270                                 scfdie();
1271
1272                         switch (enable_fmri_rec(buf, temp)) {
1273                         case 0:
1274                                 break;
1275
1276                         case EINVAL:
1277                                 uu_warn(gettext("\"%s\" dependency of \"%s\" "
1278                                     "has invalid FMRI \"%s\".\n"), pgname,
1279                                     fmri, buf);
1280                                 break;
1281
1282                         case E2BIG:
1283                                 uu_warn(gettext("%s depends on %s, which has "
1284                                     "multiple instances.\n"), fmri, buf);
1285                                 break;
1286
1287                         case ELOOP:
1288                                 ret = ELOOP;
1289                                 goto out;
1290
1291                         default:
1292                                 assert(0);
1293                                 abort();
1294                         }
1295                 }
1296         }
1297
1298         ret = 0;
1299
1300 out:
1301         he->active = B_FALSE;
1302
1303         free(buf);
1304         free(pgname);
1305
1306         (void) scf_value_destroy(v);
1307         scf_property_destroy(prop);
1308         scf_pg_destroy(pg);
1309         scf_snapshot_destroy(snap);
1310         scf_iter_destroy(pg_iter);
1311         scf_iter_destroy(val_iter);
1312
1313         return (ret);
1314 }
1315
1316 /*
1317  * fmri here is only used for verbose messages.
1318  */
1319 static void
1320 set_inst_action(const char *fmri, const scf_instance_t *inst,
1321     const char *action)
1322 {
1323         scf_transaction_t *tx;
1324         scf_transaction_entry_t *ent;
1325         scf_propertygroup_t *pg;
1326         scf_property_t *prop;
1327         scf_value_t *v;
1328         int ret;
1329         int64_t t;
1330         hrtime_t timestamp;
1331
1332         const char * const scf_pg_restarter_actions = SCF_PG_RESTARTER_ACTIONS;
1333
1334         if ((pg = scf_pg_create(h)) == NULL ||
1335             (prop = scf_property_create(h)) == NULL ||
1336             (v = scf_value_create(h)) == NULL ||
1337             (tx = scf_transaction_create(h)) == NULL ||
1338             (ent = scf_entry_create(h)) == NULL)
1339                 scfdie();
1340
1341         if (restarter_setup(fmri, inst)) {
1342                 exit_status = 1;
1343                 goto out;
1344         }
1345
1346         if (scf_instance_get_pg(inst, scf_pg_restarter_actions, pg) == -1) {
1347                 if (scf_error() != SCF_ERROR_NOT_FOUND)
1348                         scfdie();
1349
1350                 /* Try creating the restarter_actions property group. */
1351                 if (scf_instance_add_pg(inst, scf_pg_restarter_actions,
1352                     SCF_PG_RESTARTER_ACTIONS_TYPE,
1353                     SCF_PG_RESTARTER_ACTIONS_FLAGS, pg) == -1) {
1354                         switch (scf_error()) {
1355                         case SCF_ERROR_EXISTS:
1356                                 /* Someone must have added it. */
1357                                 break;
1358
1359                         case SCF_ERROR_PERMISSION_DENIED:
1360                                 if (!verbose)
1361                                         uu_warn(emsg_permission_denied, fmri);
1362                                 else
1363                                         uu_warn(emsg_create_pg_perm_denied,
1364                                             fmri, scf_pg_restarter_actions);
1365                                 goto out;
1366
1367                         default:
1368                                 scfdie();
1369                         }
1370                 }
1371         }
1372
1373         /*
1374          * If we lose the transaction race and need to retry, there are 2
1375          * potential other winners:
1376          *      - another process setting actions
1377          *      - the restarter marking the action complete
1378          * Therefore, re-read the property every time through the loop before
1379          * making any decisions based on their values.
1380          */
1381         do {
1382                 timestamp = gethrtime();
1383
1384                 if (scf_transaction_start(tx, pg) == -1) {
1385                         if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1386                                 scfdie();
1387
1388                         if (!verbose)
1389                                 uu_warn(emsg_permission_denied, fmri);
1390                         else
1391                                 uu_warn(emsg_pg_perm_denied, fmri,
1392                                     scf_pg_restarter_actions);
1393                         goto out;
1394                 }
1395
1396                 if (scf_pg_get_property(pg, action, prop) == -1) {
1397                         if (scf_error() != SCF_ERROR_NOT_FOUND)
1398                                 scfdie();
1399                         if (scf_transaction_property_new(tx, ent,
1400                             action, SCF_TYPE_INTEGER) == -1)
1401                                 scfdie();
1402                         goto action_set;
1403                 } else {
1404                         if (scf_transaction_property_change_type(tx, ent,
1405                             action, SCF_TYPE_INTEGER) == -1)
1406                                 scfdie();
1407                 }
1408
1409                 if (scf_property_get_value(prop, v) == -1) {
1410                         switch (scf_error()) {
1411                         case SCF_ERROR_CONSTRAINT_VIOLATED:
1412                         case SCF_ERROR_NOT_FOUND:
1413                                 /* Misconfigured, so set anyway. */
1414                                 goto action_set;
1415
1416                         default:
1417                                 scfdie();
1418                         }
1419                 } else {
1420                         if (scf_value_get_integer(v, &t) == -1) {
1421                                 assert(scf_error() == SCF_ERROR_TYPE_MISMATCH);
1422                                 goto action_set;
1423                         }
1424                         if (t > timestamp)
1425                                 break;
1426                 }
1427
1428 action_set:
1429                 scf_value_set_integer(v, timestamp);
1430                 if (scf_entry_add_value(ent, v) == -1)
1431                         scfdie();
1432
1433                 ret = scf_transaction_commit(tx);
1434                 if (ret == -1) {
1435                         if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1436                                 scfdie();
1437
1438                         if (!verbose)
1439                                 uu_warn(emsg_permission_denied, fmri);
1440                         else
1441                                 uu_warn(emsg_prop_perm_denied, fmri,
1442                                     scf_pg_restarter_actions, action);
1443                         scf_transaction_reset(tx);
1444                         goto out;
1445                 }
1446
1447                 scf_transaction_reset(tx);
1448
1449                 if (ret == 0) {
1450                         if (scf_pg_update(pg) == -1)
1451                                 scfdie();
1452                 }
1453         } while (ret == 0);
1454
1455         if (verbose)
1456                 (void) printf(gettext("Action %s set for %s.\n"), action, fmri);
1457
1458 out:
1459         scf_value_destroy(v);
1460         scf_entry_destroy(ent);
1461         scf_transaction_destroy(tx);
1462         scf_property_destroy(prop);
1463         scf_pg_destroy(pg);
1464 }
1465
1466 /*
1467  * Get the state of inst.  state should point to a buffer of
1468  * MAX_SCF_STATE_STRING_SZ bytes.  Returns 0 on success or -1 if
1469  *   no restarter property group
1470  *   no state property
1471  *   state property is misconfigured (wrong type, not single-valued)
1472  *   state value is too long
1473  * In these cases, fmri is used to print a warning.
1474  *
1475  * If pgp is non-NULL, a successful call to inst_get_state will store
1476  * the SCF_PG_RESTARTER property group in *pgp, and the caller will be
1477  * responsible for calling scf_pg_destroy on the property group.
1478  */
1479 int
1480 inst_get_state(scf_instance_t *inst, char *state, const char *fmri,
1481     scf_propertygroup_t **pgp)
1482 {
1483         scf_propertygroup_t *pg;
1484         scf_property_t *prop;
1485         scf_value_t *val;
1486         int ret = -1;
1487         ssize_t szret;
1488
1489         if ((pg = scf_pg_create(h)) == NULL ||
1490             (prop = scf_property_create(h)) == NULL ||
1491             (val = scf_value_create(h)) == NULL)
1492                 scfdie();
1493
1494         if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) != SCF_SUCCESS) {
1495                 if (scf_error() != SCF_ERROR_NOT_FOUND)
1496                         scfdie();
1497
1498                 uu_warn(gettext("%s is misconfigured (lacks \"%s\" property "
1499                     "group).\n"), fmri ? fmri : inst_get_fmri(inst),
1500                     SCF_PG_RESTARTER);
1501                 goto out;
1502         }
1503
1504         szret = get_astring_prop(pg, SCF_PROPERTY_STATE, prop, val, state,
1505             MAX_SCF_STATE_STRING_SZ);
1506         if (szret < 0) {
1507                 switch (-szret) {
1508                 case ENOENT:
1509                         uu_warn(gettext("%s is misconfigured (\"%s\" property "
1510                             "group lacks \"%s\" property).\n"),
1511                             fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1512                             SCF_PROPERTY_STATE);
1513                         goto out;
1514
1515                 case E2BIG:
1516                         uu_warn(gettext("%s is misconfigured (\"%s/%s\" "
1517                             "property is not single-valued).\n"),
1518                             fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1519                             SCF_PROPERTY_STATE);
1520                         goto out;
1521
1522                 case EINVAL:
1523                         uu_warn(gettext("%s is misconfigured (\"%s/%s\" "
1524                             "property is not of type astring).\n"),
1525                             fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1526                             SCF_PROPERTY_STATE);
1527                         goto out;
1528
1529                 default:
1530                         assert(0);
1531                         abort();
1532                 }
1533         }
1534         if (szret >= MAX_SCF_STATE_STRING_SZ) {
1535                 uu_warn(gettext("%s is misconfigured (\"%s/%s\" property value "
1536                     "is too long).\n"), fmri ? fmri : inst_get_fmri(inst),
1537                     SCF_PG_RESTARTER, SCF_PROPERTY_STATE);
1538                 goto out;
1539         }
1540
1541         ret = 0;
1542         if (pgp)
1543                 *pgp = pg;
1544
1545 out:
1546         (void) scf_value_destroy(val);
1547         scf_property_destroy(prop);
1548         if (ret || pgp == NULL)
1549                 scf_pg_destroy(pg);
1550         return (ret);
1551 }
1552
1553 static void
1554 set_astring_prop(const char *fmri, const char *pgname, const char *pgtype,
1555     uint32_t pgflags, const char *propname, const char *str)
1556 {
1557         scf_instance_t *inst;
1558         scf_propertygroup_t *pg;
1559         scf_property_t *prop;
1560         scf_value_t *val;
1561         scf_transaction_t *tx;
1562         scf_transaction_entry_t *txent;
1563         int ret;
1564
1565         inst = scf_instance_create(h);
1566         if (inst == NULL)
1567                 scfdie();
1568
1569         if (get_inst(fmri, inst) != 0)
1570                 return;
1571
1572         if ((pg = scf_pg_create(h)) == NULL ||
1573             (prop = scf_property_create(h)) == NULL ||
1574             (val = scf_value_create(h)) == NULL ||
1575             (tx = scf_transaction_create(h)) == NULL ||
1576             (txent = scf_entry_create(h)) == NULL)
1577                 scfdie();
1578
1579         if (scf_instance_get_pg(inst, pgname, pg) != SCF_SUCCESS) {
1580                 if (scf_error() != SCF_ERROR_NOT_FOUND)
1581                         scfdie();
1582
1583                 if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) !=
1584                     SCF_SUCCESS) {
1585                         switch (scf_error()) {
1586                         case SCF_ERROR_EXISTS:
1587                                 if (scf_instance_get_pg(inst, pgname, pg) !=
1588                                     SCF_SUCCESS) {
1589                                         if (scf_error() != SCF_ERROR_NOT_FOUND)
1590                                                 scfdie();
1591
1592                                         uu_warn(gettext("Repository write "
1593                                             "contention.\n"));
1594                                         goto out;
1595                                 }
1596                                 break;
1597
1598                         case SCF_ERROR_PERMISSION_DENIED:
1599                                 if (!verbose)
1600                                         uu_warn(emsg_permission_denied, fmri);
1601                                 else
1602                                         uu_warn(emsg_create_pg_perm_denied,
1603                                             fmri, pgname);
1604                                 goto out;
1605
1606                         default:
1607                                 scfdie();
1608                         }
1609                 }
1610         }
1611
1612         do {
1613                 if (scf_transaction_start(tx, pg) != SCF_SUCCESS) {
1614                         if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1615                                 scfdie();
1616
1617                         if (!verbose)
1618                                 uu_warn(emsg_permission_denied, fmri);
1619                         else
1620                                 uu_warn(emsg_pg_perm_denied, fmri, pgname);
1621                         goto out;
1622                 }
1623
1624                 if (scf_transaction_property_change_type(tx, txent, propname,
1625                     SCF_TYPE_ASTRING) != 0) {
1626                         if (scf_error() != SCF_ERROR_NOT_FOUND)
1627                                 scfdie();
1628
1629                         if (scf_transaction_property_new(tx, txent, propname,
1630                             SCF_TYPE_ASTRING) != 0)
1631                                 scfdie();
1632                 }
1633
1634                 if (scf_value_set_astring(val, str) != SCF_SUCCESS)
1635                         scfdie();
1636
1637                 if (scf_entry_add_value(txent, val) != SCF_SUCCESS)
1638                         scfdie();
1639
1640                 ret = scf_transaction_commit(tx);
1641                 if (ret == -1) {
1642                         if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1643                                 scfdie();
1644
1645                         if (!verbose)
1646                                 uu_warn(emsg_permission_denied, fmri);
1647                         else
1648                                 uu_warn(emsg_prop_perm_denied, fmri, pgname,
1649                                     propname);
1650                         goto out;
1651                 }
1652
1653                 if (ret == 0) {
1654                         scf_transaction_reset(tx);
1655
1656                         if (scf_pg_update(pg) == -1)
1657                                 scfdie();
1658                 }
1659         } while (ret == 0);
1660
1661 out:
1662         scf_transaction_destroy(tx);
1663         scf_entry_destroy(txent);
1664         scf_value_destroy(val);
1665         scf_property_destroy(prop);
1666         scf_pg_destroy(pg);
1667         scf_instance_destroy(inst);
1668 }
1669
1670
1671 /*
1672  * Flags to control enable and disable actions.
1673  */
1674 #define SET_ENABLED     0x1
1675 #define SET_TEMPORARY   0x2
1676 #define SET_RECURSIVE   0x4
1677
1678 static int
1679 set_fmri_enabled(void *data, scf_walkinfo_t *wip)
1680 {
1681         int flags = (int)data;
1682
1683         assert(wip->inst != NULL);
1684         assert(wip->pg == NULL);
1685
1686         if (svcsearch) {
1687                 char state[MAX_SCF_STATE_STRING_SZ];
1688
1689                 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1690                         return (0);
1691                 if (strcmp(state, svcstate) != 0)
1692                         return (0);
1693         }
1694
1695         if (flags & SET_RECURSIVE) {
1696                 char *fmri_buf = malloc(max_scf_fmri_sz);
1697                 if (fmri_buf == NULL)
1698                         uu_die(emsg_nomem);
1699
1700                 visited = calloc(HT_BUCKETS, sizeof (*visited));
1701                 if (visited == NULL)
1702                         uu_die(emsg_nomem);
1703
1704                 /* scf_walk_fmri() guarantees that fmri isn't too long */
1705                 assert(strlen(wip->fmri) <= max_scf_fmri_sz);
1706                 (void) strlcpy(fmri_buf, wip->fmri, max_scf_fmri_sz);
1707
1708                 switch (enable_fmri_rec(fmri_buf, (flags & SET_TEMPORARY))) {
1709                 case E2BIG:
1710                         uu_warn(gettext("operation on service %s is ambiguous; "
1711                             "instance specification needed.\n"), fmri_buf);
1712                         break;
1713
1714                 case ELOOP:
1715                         uu_warn(gettext("%s: Dependency cycle detected.\n"),
1716                             fmri_buf);
1717                 }
1718
1719                 free(visited);
1720                 free(fmri_buf);
1721
1722         } else {
1723                 set_inst_enabled(wip->fmri, wip->inst,
1724                     (flags & SET_TEMPORARY) != 0, (flags & SET_ENABLED) != 0);
1725         }
1726
1727         return (0);
1728 }
1729
1730 /* ARGSUSED */
1731 static int
1732 wait_fmri_enabled(void *data, scf_walkinfo_t *wip)
1733 {
1734         scf_propertygroup_t *pg = NULL;
1735         char state[MAX_SCF_STATE_STRING_SZ];
1736
1737         assert(wip->inst != NULL);
1738         assert(wip->pg == NULL);
1739
1740         do {
1741                 if (pg)
1742                         scf_pg_destroy(pg);
1743                 if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) {
1744                         exit_status = EXIT_SVC_FAILURE;
1745                         return (0);
1746                 }
1747
1748                 if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0 ||
1749                     strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) {
1750                         /*
1751                          * We're done.
1752                          */
1753                         goto out;
1754                 }
1755
1756                 if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
1757                         /*
1758                          * The service is ill.
1759                          */
1760                         uu_warn(gettext("Instance \"%s\" is in maintenance"
1761                             " state.\n"), wip->fmri);
1762                         exit_status = EXIT_SVC_FAILURE;
1763                         goto out;
1764                 }
1765
1766                 if (!is_enabled(wip->inst)) {
1767                         /*
1768                          * Someone stepped in and disabled the service.
1769                          */
1770                         uu_warn(gettext("Instance \"%s\" has been disabled"
1771                             " by another entity.\n"), wip->fmri);
1772                         exit_status = EXIT_SVC_FAILURE;
1773                         goto out;
1774                 }
1775
1776                 if (!has_potential(wip->inst, B_FALSE)) {
1777                         /*
1778                          * Our dependencies aren't met.  We'll never
1779                          * amount to anything.
1780                          */
1781                         uu_warn(gettext("Instance \"%s\" has unsatisfied"
1782                             " dependencies.\n"), wip->fmri);
1783                         /*
1784                          * EXIT_SVC_FAILURE takes precedence over
1785                          * EXIT_DEP_FAILURE
1786                          */
1787                         if (exit_status == 0)
1788                                 exit_status = EXIT_DEP_FAILURE;
1789                         goto out;
1790                 }
1791         } while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0);
1792         scfdie();
1793         /* NOTREACHED */
1794
1795 out:
1796         scf_pg_destroy(pg);
1797         return (0);
1798 }
1799
1800 /* ARGSUSED */
1801 static int
1802 wait_fmri_disabled(void *data, scf_walkinfo_t *wip)
1803 {
1804         scf_propertygroup_t *pg = NULL;
1805         char state[MAX_SCF_STATE_STRING_SZ];
1806
1807         assert(wip->inst != NULL);
1808         assert(wip->pg == NULL);
1809
1810         do {
1811                 if (pg)
1812                         scf_pg_destroy(pg);
1813                 if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) {
1814                         exit_status = EXIT_SVC_FAILURE;
1815                         return (0);
1816                 }
1817
1818                 if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) {
1819                         /*
1820                          * We're done.
1821                          */
1822                         goto out;
1823                 }
1824
1825                 if (is_enabled(wip->inst)) {
1826                         /*
1827                          * Someone stepped in and enabled the service.
1828                          */
1829                         uu_warn(gettext("Instance \"%s\" has been enabled"
1830                             " by another entity.\n"), wip->fmri);
1831                         exit_status = EXIT_SVC_FAILURE;
1832                         goto out;
1833                 }
1834
1835                 if (!has_potential(wip->inst, B_TRUE)) {
1836                         /*
1837                          * Our restarter is hopeless.
1838                          */
1839                         uu_warn(gettext("Restarter for instance \"%s\" is"
1840                             " unavailable.\n"), wip->fmri);
1841                         /*
1842                          * EXIT_SVC_FAILURE takes precedence over
1843                          * EXIT_DEP_FAILURE
1844                          */
1845                         if (exit_status == 0)
1846                                 exit_status = EXIT_DEP_FAILURE;
1847                         goto out;
1848                 }
1849
1850         } while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0);
1851         scfdie();
1852         /* NOTREACHED */
1853
1854 out:
1855         scf_pg_destroy(pg);
1856         return (0);
1857 }
1858
1859 /* ARGSUSED */
1860 static int
1861 clear_instance(void *data, scf_walkinfo_t *wip)
1862 {
1863         char state[MAX_SCF_STATE_STRING_SZ];
1864
1865         assert(wip->inst != NULL);
1866         assert(wip->pg == NULL);
1867
1868         if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1869                 return (0);
1870
1871         if (svcsearch && strcmp(state, svcstate) != 0)
1872                 return (0);
1873
1874         if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
1875                 set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_MAINT_OFF);
1876         } else if (strcmp(state, SCF_STATE_STRING_DEGRADED) ==
1877             0) {
1878                 set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_RESTORE);
1879         } else {
1880                 uu_warn(gettext("Instance \"%s\" is not in a "
1881                     "maintenance or degraded state.\n"), wip->fmri);
1882
1883                 exit_status = 1;
1884         }
1885
1886         return (0);
1887 }
1888
1889 static int
1890 set_fmri_action(void *action, scf_walkinfo_t *wip)
1891 {
1892         assert(wip->inst != NULL && wip->pg == NULL);
1893
1894         if (svcsearch) {
1895                 char state[MAX_SCF_STATE_STRING_SZ];
1896
1897                 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1898                         return (0);
1899                 if (strcmp(state, svcstate) != 0)
1900                         return (0);
1901         }
1902
1903         set_inst_action(wip->fmri, wip->inst, action);
1904
1905         return (0);
1906 }
1907
1908 /*
1909  * Flags to control 'mark' action.
1910  */
1911 #define MARK_IMMEDIATE  0x1
1912 #define MARK_TEMPORARY  0x2
1913
1914 static int
1915 force_degraded(void *data, scf_walkinfo_t *wip)
1916 {
1917         int flags = (int)data;
1918         char state[MAX_SCF_STATE_STRING_SZ];
1919
1920         if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) {
1921                 exit_status = 1;
1922                 return (0);
1923         }
1924
1925         if (svcsearch && strcmp(state, svcstate) != 0)
1926                 return (0);
1927
1928         if (strcmp(state, SCF_STATE_STRING_ONLINE) != 0) {
1929                 uu_warn(gettext("Instance \"%s\" is not online.\n"), wip->fmri);
1930                 exit_status = 1;
1931                 return (0);
1932         }
1933
1934         set_inst_action(wip->fmri, wip->inst, (flags & MARK_IMMEDIATE) ?
1935             SCF_PROPERTY_DEGRADE_IMMEDIATE : SCF_PROPERTY_DEGRADED);
1936
1937         return (0);
1938 }
1939
1940 static int
1941 force_maintenance(void *data, scf_walkinfo_t *wip)
1942 {
1943         int flags = (int)data;
1944         const char *prop;
1945
1946         if (svcsearch) {
1947                 char state[MAX_SCF_STATE_STRING_SZ];
1948
1949                 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1950                         return (0);
1951                 if (strcmp(state, svcstate) != 0)
1952                         return (0);
1953         }
1954
1955         if (flags & MARK_IMMEDIATE) {
1956                 prop = (flags & MARK_TEMPORARY) ?
1957                     SCF_PROPERTY_MAINT_ON_IMMTEMP :
1958                     SCF_PROPERTY_MAINT_ON_IMMEDIATE;
1959         } else {
1960                 prop = (flags & MARK_TEMPORARY) ?
1961                     SCF_PROPERTY_MAINT_ON_TEMPORARY :
1962                     SCF_PROPERTY_MAINT_ON;
1963         }
1964
1965         set_inst_action(wip->fmri, wip->inst, prop);
1966
1967         return (0);
1968 }
1969
1970 static void
1971 set_milestone(const char *fmri, boolean_t temporary)
1972 {
1973         scf_instance_t *inst;
1974         scf_propertygroup_t *pg;
1975         int r;
1976
1977         if (temporary) {
1978                 set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS_OVR,
1979                     SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS,
1980                     SCF_PROPERTY_MILESTONE, fmri);
1981                 return;
1982         }
1983
1984         if ((inst = scf_instance_create(h)) == NULL ||
1985             (pg = scf_pg_create(h)) == NULL)
1986                 scfdie();
1987
1988         if (get_inst(SCF_SERVICE_STARTD, inst) != 0) {
1989                 scf_instance_destroy(inst);
1990                 return;
1991         }
1992
1993         /*
1994          * Set the persistent milestone before deleting the override so we don't
1995          * glitch.
1996          */
1997         set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS,
1998             SCF_PG_OPTIONS_TYPE, SCF_PG_OPTIONS_FLAGS, SCF_PROPERTY_MILESTONE,
1999             fmri);
2000
2001         r = scf_instance_delete_prop(inst, SCF_PG_OPTIONS_OVR,
2002             SCF_PROPERTY_MILESTONE);
2003         switch (r) {
2004         case 0:
2005                 break;
2006
2007         case ECANCELED:
2008                 uu_warn(emsg_no_service, fmri);
2009                 exit_status = 1;
2010                 goto out;
2011
2012         case EPERM:
2013                 uu_warn(gettext("Could not delete %s/%s property of "
2014                     "%s: permission denied.\n"), SCF_PG_OPTIONS_OVR,
2015                     SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2016                 exit_status = 1;
2017                 goto out;
2018
2019         case EACCES:
2020                 uu_warn(gettext("Could not delete %s/%s property of "
2021                     "%s: access denied.\n"), SCF_PG_OPTIONS_OVR,
2022                     SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2023                 exit_status = 1;
2024                 goto out;
2025
2026         case EROFS:
2027                 uu_warn(gettext("Could not delete %s/%s property of "
2028                     "%s: backend read-only.\n"), SCF_PG_OPTIONS_OVR,
2029                     SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2030                 exit_status = 1;
2031                 goto out;
2032
2033         default:
2034                 bad_error("scf_instance_delete_prop", r);
2035         }
2036
2037 out:
2038         scf_pg_destroy(pg);
2039         scf_instance_destroy(inst);
2040 }
2041
2042 static char const *milestones[] = {
2043         SCF_MILESTONE_SINGLE_USER,
2044         SCF_MILESTONE_MULTI_USER,
2045         SCF_MILESTONE_MULTI_USER_SERVER,
2046         NULL
2047 };
2048
2049 static void
2050 usage_milestone(void)
2051 {
2052         const char **ms;
2053
2054         (void) fprintf(stderr, gettext(
2055         "Usage: svcadm milestone [-d] <milestone>\n\n"
2056         "\t-d\tmake the specified milestone the default for system boot\n\n"
2057         "\tMilestones can be specified using an FMRI or abbreviation.\n"
2058         "\tThe major milestones are as follows:\n\n"
2059         "\tall\n"
2060         "\tnone\n"));
2061
2062         for (ms = milestones; *ms != NULL; ms++)
2063                 (void) fprintf(stderr, "\t%s\n", *ms);
2064
2065         exit(UU_EXIT_USAGE);
2066 }
2067
2068 static const char *
2069 validate_milestone(const char *milestone)
2070 {
2071         const char **ms;
2072         const char *tmp;
2073         size_t len;
2074
2075         if (strcmp(milestone, "all") == 0)
2076                 return (milestone);
2077
2078         if (strcmp(milestone, "none") == 0)
2079                 return (milestone);
2080
2081         /*
2082          * Determine if this is a full or partial milestone
2083          */
2084         for (ms = milestones; *ms != NULL; ms++) {
2085                 if ((tmp = strstr(*ms, milestone)) != NULL) {
2086                         len = strlen(milestone);
2087
2088                         /*
2089                          * The beginning of the string must align with the start
2090                          * of a milestone fmri, or on the boundary between
2091                          * elements.  The end of the string must align with the
2092                          * end of the milestone, or at the instance boundary.
2093                          */
2094                         if ((tmp == *ms || tmp[-1] == '/') &&
2095                             (tmp[len] == '\0' || tmp[len] == ':'))
2096                                 return (*ms);
2097                 }
2098         }
2099
2100         (void) fprintf(stderr,
2101             gettext("\"%s\" is not a valid major milestone.\n"), milestone);
2102
2103         usage_milestone();
2104         /* NOTREACHED */
2105 }
2106
2107 /*PRINTFLIKE1*/
2108 static void
2109 pr_warn(const char *format, ...)
2110 {
2111         const char *pname = uu_getpname();
2112         va_list alist;
2113
2114         va_start(alist, format);
2115
2116         if (pname != NULL)
2117                 (void) fprintf(stderr, "%s", pname);
2118
2119         if (g_zonename != NULL)
2120                 (void) fprintf(stderr, " (%s)", g_zonename);
2121
2122         (void) fprintf(stderr, ": ");
2123
2124         (void) vfprintf(stderr, format, alist);
2125
2126         if (strrchr(format, '\n') == NULL)
2127                 (void) fprintf(stderr, ": %s\n", strerror(errno));
2128
2129         va_end(alist);
2130 }
2131
2132 /*ARGSUSED*/
2133 static void
2134 quiet(const char *fmt, ...)
2135 {
2136         /* Do nothing */
2137 }
2138
2139 int
2140 main(int argc, char *argv[])
2141 {
2142         int o;
2143         int err;
2144         int sw_back;
2145         boolean_t do_zones = B_FALSE;
2146         boolean_t do_a_zone = B_FALSE;
2147         char zonename[ZONENAME_MAX];
2148         uint_t nzents = 0, zent = 0;
2149         zoneid_t *zids = NULL;
2150         int orig_optind, orig_argc;
2151         char **orig_argv;
2152
2153         (void) setlocale(LC_ALL, "");
2154         (void) textdomain(TEXT_DOMAIN);
2155
2156         (void) uu_setpname(argv[0]);
2157
2158         if (argc < 2)
2159                 usage();
2160
2161         max_scf_fmri_sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
2162         if (max_scf_fmri_sz < 0)
2163                 scfdie();
2164         ++max_scf_fmri_sz;
2165
2166         scratch_fmri = malloc(max_scf_fmri_sz);
2167         if (scratch_fmri == NULL)
2168                 uu_die(emsg_nomem);
2169
2170         while ((o = getopt(argc, argv, "S:vZz:")) != -1) {
2171                 switch (o) {
2172                 case 'S':
2173                         (void) strlcpy(svcstate, optarg, sizeof (svcstate));
2174                         svcsearch = B_TRUE;
2175                         break;
2176
2177                 case 'v':
2178                         verbose = 1;
2179                         break;
2180
2181                 case 'z':
2182                         if (getzoneid() != GLOBAL_ZONEID)
2183                                 uu_die(gettext("svcadm -z may only be used "
2184                                     "from the global zone\n"));
2185                         if (do_zones)
2186                                 usage();
2187
2188                         (void) strlcpy(zonename, optarg, sizeof (zonename));
2189                         do_a_zone = B_TRUE;
2190                         break;
2191
2192                 case 'Z':
2193                         if (getzoneid() != GLOBAL_ZONEID)
2194                                 uu_die(gettext("svcadm -Z may only be used "
2195                                     "from the global zone\n"));
2196                         if (do_a_zone)
2197                                 usage();
2198
2199                         do_zones = B_TRUE;
2200                         break;
2201
2202                 default:
2203                         usage();
2204                 }
2205         }
2206
2207         while (do_zones) {
2208                 uint_t found;
2209
2210                 if (zone_list(NULL, &nzents) != 0)
2211                         uu_die(gettext("could not get number of zones"));
2212
2213                 if ((zids = malloc(nzents * sizeof (zoneid_t))) == NULL) {
2214                         uu_die(gettext("could not allocate array for "
2215                             "%d zone IDs"), nzents);
2216                 }
2217
2218                 found = nzents;
2219
2220                 if (zone_list(zids, &found) != 0)
2221                         uu_die(gettext("could not get zone list"));
2222
2223                 /*
2224                  * If the number of zones has not changed between our calls to
2225                  * zone_list(), we're done -- otherwise, we must free our array
2226                  * of zone IDs and take another lap.
2227                  */
2228                 if (found == nzents)
2229                         break;
2230
2231                 free(zids);
2232         }
2233
2234         emsg_permission_denied = gettext("%s: Permission denied.\n");
2235         emsg_nomem = gettext("Out of memory.\n");
2236         emsg_create_pg_perm_denied = gettext("%s: Couldn't create \"%s\" "
2237             "property group (permission denied).\n");
2238         emsg_pg_perm_denied = gettext("%s: Couldn't modify \"%s\" property "
2239             "group (permission denied).\n");
2240         emsg_prop_perm_denied = gettext("%s: Couldn't modify \"%s/%s\" "
2241             "property (permission denied).\n");
2242         emsg_no_service = gettext("No such service \"%s\".\n");
2243
2244         orig_optind = optind;
2245         orig_argc = argc;
2246         orig_argv = argv;
2247
2248 again:
2249         h = scf_handle_create(SCF_VERSION);
2250         if (h == NULL)
2251                 scfdie();
2252
2253         if (do_zones) {
2254                 zone_status_t status;
2255
2256                 if (zone_getattr(zids[zent], ZONE_ATTR_STATUS, &status,
2257                     sizeof (status)) < 0 || status != ZONE_IS_RUNNING) {
2258                         /*
2259                          * If this zone is not running or we cannot
2260                          * get its status, we do not want to attempt
2261                          * to bind an SCF handle to it, lest we
2262                          * accidentally interfere with a zone that
2263                          * is not yet running by looking up a door
2264                          * to its svc.configd (which could potentially
2265                          * block a mount with an EBUSY).
2266                          */
2267                         zent++;
2268                         goto nextzone;
2269                 }
2270
2271                 if (getzonenamebyid(zids[zent++], zonename,
2272                     sizeof (zonename)) < 0) {
2273                         uu_warn(gettext("could not get name for "
2274                             "zone %d; ignoring"), zids[zent - 1]);
2275                         goto nextzone;
2276                 }
2277
2278                 g_zonename = zonename;
2279         }
2280
2281         if (do_a_zone || do_zones) {
2282                 scf_value_t *zone;
2283
2284                 if ((zone = scf_value_create(h)) == NULL)
2285                         scfdie();
2286
2287                 if (scf_value_set_astring(zone, zonename) != SCF_SUCCESS)
2288                         scfdie();
2289
2290                 if (scf_handle_decorate(h, "zone", zone) != SCF_SUCCESS) {
2291                         if (do_a_zone) {
2292                                 uu_die(gettext("invalid zone '%s'\n"), optarg);
2293                         } else {
2294                                 scf_value_destroy(zone);
2295                                 goto nextzone;
2296                         }
2297                 }
2298
2299                 scf_value_destroy(zone);
2300         }
2301
2302         if (scf_handle_bind(h) == -1) {
2303                 if (do_zones)
2304                         goto nextzone;
2305
2306                 uu_die(gettext("Couldn't bind to configuration repository: "
2307                     "%s.\n"), scf_strerror(scf_error()));
2308         }
2309
2310         optind = orig_optind;
2311         argc = orig_argc;
2312         argv = orig_argv;
2313
2314         if (optind >= argc)
2315                 usage();
2316
2317         if (strcmp(argv[optind], "enable") == 0) {
2318                 int flags = SET_ENABLED;
2319                 int wait = 0;
2320                 int error = 0;
2321
2322                 ++optind;
2323
2324                 while ((o = getopt(argc, argv, "rst")) != -1) {
2325                         if (o == 'r')
2326                                 flags |= SET_RECURSIVE;
2327                         else if (o == 't')
2328                                 flags |= SET_TEMPORARY;
2329                         else if (o == 's')
2330                                 wait = 1;
2331                         else if (o == '?')
2332                                 usage();
2333                         else {
2334                                 assert(0);
2335                                 abort();
2336                         }
2337                 }
2338                 argc -= optind;
2339                 argv += optind;
2340
2341                 if (argc == 0 && !svcsearch)
2342                         usage();
2343
2344                 if (argc > 0 && svcsearch)
2345                         usage();
2346
2347                 /*
2348                  * We want to continue with -s processing if we had
2349                  * invalid options, but not if an enable failed.  We
2350                  * squelch output the second time we walk fmris; we saw
2351                  * the errors the first time.
2352                  */
2353                 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2354                     set_fmri_enabled, (void *)flags, &error, pr_warn)) != 0) {
2355
2356                         pr_warn(gettext("failed to iterate over "
2357                             "instances: %s\n"), scf_strerror(err));
2358                         exit_status = UU_EXIT_FATAL;
2359
2360                 } else if (wait && exit_status == 0 &&
2361                     (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2362                     wait_fmri_enabled, (void *)flags, &error, quiet)) != 0) {
2363
2364                         pr_warn(gettext("failed to iterate over "
2365                             "instances: %s\n"), scf_strerror(err));
2366                         exit_status = UU_EXIT_FATAL;
2367                 }
2368
2369                 if (error > 0)
2370                         exit_status = error;
2371
2372         } else if (strcmp(argv[optind], "disable") == 0) {
2373                 int flags = 0;
2374                 int wait = 0;
2375                 int error = 0;
2376
2377                 ++optind;
2378
2379                 while ((o = getopt(argc, argv, "st")) != -1) {
2380                         if (o == 't')
2381                                 flags |= SET_TEMPORARY;
2382                         else if (o == 's')
2383                                 wait = 1;
2384                         else if (o == '?')
2385                                 usage();
2386                         else {
2387                                 assert(0);
2388                                 abort();
2389                         }
2390                 }
2391                 argc -= optind;
2392                 argv += optind;
2393
2394                 if (argc == 0 && !svcsearch)
2395                         usage();
2396
2397                 if (argc > 0 && svcsearch)
2398                         usage();
2399
2400                 /*
2401                  * We want to continue with -s processing if we had
2402                  * invalid options, but not if a disable failed.  We
2403                  * squelch output the second time we walk fmris; we saw
2404                  * the errors the first time.
2405                  */
2406                 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2407                     set_fmri_enabled, (void *)flags, &exit_status,
2408                     pr_warn)) != 0) {
2409
2410                         pr_warn(gettext("failed to iterate over "
2411                             "instances: %s\n"), scf_strerror(err));
2412                         exit_status = UU_EXIT_FATAL;
2413
2414                 } else if (wait && exit_status == 0 &&
2415                     (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2416                     wait_fmri_disabled, (void *)flags, &error, quiet)) != 0) {
2417
2418                         pr_warn(gettext("failed to iterate over "
2419                             "instances: %s\n"), scf_strerror(err));
2420                         exit_status = UU_EXIT_FATAL;
2421                 }
2422
2423                 if (error > 0)
2424                         exit_status = error;
2425
2426         } else if (strcmp(argv[optind], "restart") == 0) {
2427                 boolean_t do_dump = B_FALSE;
2428
2429                 ++optind;
2430
2431                 while ((o = getopt(argc, argv, "d")) != -1) {
2432                         if (o == 'd')
2433                                 do_dump = B_TRUE;
2434                         else if (o == '?')
2435                                 usage();
2436                         else {
2437                                 assert(0);
2438                                 abort();
2439                         }
2440                 }
2441                 argc -= optind;
2442                 argv += optind;
2443
2444                 if (argc == 0 && !svcsearch)
2445                         usage();
2446
2447                 if (argc > 0 && svcsearch)
2448                         usage();
2449
2450                 if (do_dump) {
2451                         if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2452                             set_fmri_action, (void *)SCF_PROPERTY_DODUMP,
2453                             &exit_status, pr_warn)) != 0) {
2454                                 pr_warn(gettext("failed to iterate over "
2455                                     "instances: %s\n"), scf_strerror(err));
2456                                 exit_status = UU_EXIT_FATAL;
2457                         }
2458                 }
2459
2460                 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2461                     set_fmri_action, (void *)SCF_PROPERTY_RESTART, &exit_status,
2462                     pr_warn)) != 0) {
2463                         pr_warn(gettext("failed to iterate over "
2464                             "instances: %s\n"), scf_strerror(err));
2465                         exit_status = UU_EXIT_FATAL;
2466                 }
2467
2468         } else if (strcmp(argv[optind], "refresh") == 0) {
2469                 ++optind;
2470                 argc -= optind;
2471                 argv += optind;
2472
2473                 if (argc == 0 && !svcsearch)
2474                         usage();
2475
2476                 if (argc > 0 && svcsearch)
2477                         usage();
2478
2479                 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2480                     set_fmri_action, (void *)SCF_PROPERTY_REFRESH, &exit_status,
2481                     pr_warn)) != 0) {
2482                         pr_warn(gettext("failed to iterate over "
2483                             "instances: %s\n"), scf_strerror(scf_error()));
2484                         exit_status = UU_EXIT_FATAL;
2485                 }
2486
2487         } else if (strcmp(argv[optind], "mark") == 0) {
2488                 int flags = 0;
2489                 scf_walk_callback callback;
2490
2491                 ++optind;
2492
2493                 while ((o = getopt(argc, argv, "It")) != -1) {
2494                         if (o == 'I')
2495                                 flags |= MARK_IMMEDIATE;
2496                         else if (o == 't')
2497                                 flags |= MARK_TEMPORARY;
2498                         else if (o == '?')
2499                                 usage();
2500                         else {
2501                                 assert(0);
2502                                 abort();
2503                         }
2504                 }
2505
2506                 if (argc - optind < 2)
2507                         usage();
2508
2509                 if (strcmp(argv[optind], "degraded") == 0) {
2510                         if (flags & MARK_TEMPORARY)
2511                                 uu_xdie(UU_EXIT_USAGE, gettext("-t may not be "
2512                                     "used with degraded.\n"));
2513                         callback = force_degraded;
2514
2515                 } else if (strcmp(argv[optind], "maintenance") == 0) {
2516                         callback = force_maintenance;
2517                 } else {
2518                         usage();
2519                 }
2520
2521                 optind++;
2522                 argc -= optind;
2523                 argv += optind;
2524
2525                 if (argc == 0 && !svcsearch)
2526                         usage();
2527
2528                 if (argc > 0 && svcsearch)
2529                         usage();
2530
2531                 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, callback,
2532                     NULL, &exit_status, pr_warn)) != 0) {
2533                         pr_warn(gettext("failed to iterate over "
2534                             "instances: %s\n"),
2535                             scf_strerror(err));
2536                         exit_status = UU_EXIT_FATAL;
2537                 }
2538
2539         } else if (strcmp(argv[optind], "clear") == 0) {
2540                 ++optind;
2541                 argc -= optind;
2542                 argv += optind;
2543
2544                 if (argc == 0 && !svcsearch)
2545                         usage();
2546
2547                 if (svcsearch) {
2548                         if (argc > 0)
2549                                 usage();
2550                         if (strcmp(svcstate, SCF_STATE_STRING_MAINT) != 0 &&
2551                             strcmp(svcstate, SCF_STATE_STRING_DEGRADED) != 0)
2552                                 uu_die(gettext("State must be '%s' or '%s'\n"),
2553                                     SCF_STATE_STRING_MAINT,
2554                                     SCF_STATE_STRING_DEGRADED);
2555                 }
2556
2557                 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2558                     clear_instance, NULL, &exit_status, pr_warn)) != 0) {
2559                         pr_warn(gettext("failed to iterate over "
2560                             "instances: %s\n"), scf_strerror(err));
2561                         exit_status = UU_EXIT_FATAL;
2562                 }
2563
2564         } else if (strcmp(argv[optind], "milestone") == 0) {
2565                 boolean_t temporary = B_TRUE;
2566                 const char *milestone;
2567
2568                 ++optind;
2569
2570                 while ((o = getopt(argc, argv, "d")) != -1) {
2571                         if (o == 'd')
2572                                 temporary = B_FALSE;
2573                         else if (o == '?')
2574                                 usage_milestone();
2575                         else {
2576                                 assert(0);
2577                                 abort();
2578                         }
2579                 }
2580
2581                 if (optind >= argc)
2582                         usage_milestone();
2583
2584                 milestone = validate_milestone(argv[optind]);
2585
2586                 set_milestone(milestone, temporary);
2587         } else if (strcmp(argv[optind], "_smf_backup") == 0) {
2588                 const char *reason = NULL;
2589
2590                 ++optind;
2591
2592                 if (optind != argc - 1)
2593                         usage();
2594
2595                 if ((err = _scf_request_backup(h, argv[optind])) !=
2596                     SCF_SUCCESS) {
2597                         switch (scf_error()) {
2598                         case SCF_ERROR_NOT_BOUND:
2599                         case SCF_ERROR_CONNECTION_BROKEN:
2600                         case SCF_ERROR_BACKEND_READONLY:
2601                                 scfdie();
2602                                 break;
2603
2604                         case SCF_ERROR_PERMISSION_DENIED:
2605                         case SCF_ERROR_INVALID_ARGUMENT:
2606                                 reason = scf_strerror(scf_error());
2607                                 break;
2608
2609                         case SCF_ERROR_INTERNAL:
2610                                 reason =
2611                                     "unknown error (see console for details)";
2612                                 break;
2613                         }
2614
2615                         pr_warn("failed to backup repository: %s\n", reason);
2616                         exit_status = UU_EXIT_FATAL;
2617                 }
2618         } else if (strcmp(argv[optind], "_smf_repository_switch") == 0) {
2619                 const char *reason = NULL;
2620
2621                 ++optind;
2622
2623                 /*
2624                  * Check argument and setup scf_switch structure
2625                  */
2626                 if (optind != argc - 1)
2627                         exit(1);
2628
2629                 if (strcmp(argv[optind], "fast") == 0) {
2630                         sw_back = 0;
2631                 } else if (strcmp(argv[optind], "perm") == 0) {
2632                         sw_back = 1;
2633                 } else {
2634                         exit(UU_EXIT_USAGE);
2635                 }
2636
2637                 /*
2638                  * Call into switch primitive
2639                  */
2640                 if ((err = _scf_repository_switch(h, sw_back)) !=
2641                     SCF_SUCCESS) {
2642                         /*
2643                          * Retrieve per thread SCF error code
2644                          */
2645                         switch (scf_error()) {
2646                         case SCF_ERROR_NOT_BOUND:
2647                                 abort();
2648                                 /* NOTREACHED */
2649
2650                         case SCF_ERROR_CONNECTION_BROKEN:
2651                         case SCF_ERROR_BACKEND_READONLY:
2652                                 scfdie();
2653                                 /* NOTREACHED */
2654
2655                         case SCF_ERROR_PERMISSION_DENIED:
2656                         case SCF_ERROR_INVALID_ARGUMENT:
2657                                 reason = scf_strerror(scf_error());
2658                                 break;
2659
2660                         case SCF_ERROR_INTERNAL:
2661                                 reason = "File operation error: (see console)";
2662                                 break;
2663
2664                         default:
2665                                 abort();
2666                                 /* NOTREACHED */
2667                         }
2668
2669                         pr_warn("failed to switch repository: %s\n", reason);
2670                         exit_status = UU_EXIT_FATAL;
2671                 }
2672         } else {
2673                 usage();
2674         }
2675
2676         if (scf_handle_unbind(h) == -1)
2677                 scfdie();
2678 nextzone:
2679         scf_handle_destroy(h);
2680         if (do_zones && zent < nzents)
2681                 goto again;
2682
2683         return (exit_status);
2684 }