usr/src/lib/libndmp/common/libndmp_prop.c

   1 /*
   2  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  * Copyright 2012 Milan Jurik. All rights reserved.
   5  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
   6  */
   7
   8 /*
   9  * BSD 3 Clause License
  10  *
  11  * Copyright (c) 2007, The Storage Networking Industry Association.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  *      - Redistributions of source code must retain the above copyright
  17  *        notice, this list of conditions and the following disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above copyright
  20  *        notice, this list of conditions and the following disclaimer in
  21  *        the documentation and/or other materials provided with the
  22  *        distribution.
  23  *
  24  *      - Neither the name of The Storage Networking Industry Association (SNIA)
  25  *        nor the names of its contributors may be used to endorse or promote
  26  *        products derived from this software without specific prior written
  27  *        permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  30  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  33  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39  * POSSIBILITY OF SUCH DAMAGE.
  40  */
  41
  42 /*
  43  * NDMP configuration management
  44  */
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <synch.h>
  48 #include <libintl.h>
  49 #include <strings.h>
  50 #include <libndmp.h>
  51
  52 /* NDMP properties configuration */
  53 #define NDMP_GROUP_FMRI_PREFIX  "system/ndmpd"
  54 #define NDMP_INST               "svc:/system/ndmpd:default"
  55 #define NDMP_PROP_LEN           600
  56 static char *ndmp_pg[] = {
  57         "ndmpd",
  58         "read"
  59 };
  60 #define NPG     (sizeof (ndmp_pg) / sizeof (ndmp_pg[0]))
  61
  62 /* Handle Init states */
  63 #define NDMP_SCH_STATE_UNINIT           0
  64 #define NDMP_SCH_STATE_INITIALIZING     1
  65 #define NDMP_SCH_STATE_INIT             2
  66
  67 /* NDMP scf handle structure */
  68 typedef struct ndmp_scfhandle {
  69         scf_handle_t *scf_handle;
  70         int scf_state;
  71         scf_service_t *scf_service;
  72         scf_scope_t *scf_scope;
  73         scf_transaction_t *scf_trans;
  74         scf_propertygroup_t *scf_pg;
  75 } ndmp_scfhandle_t;
  76
  77 static int ndmp_config_saveenv(ndmp_scfhandle_t *, boolean_t);
  78 static ndmp_scfhandle_t *ndmp_smf_scf_init(const char *);
  79 static void ndmp_smf_scf_fini(ndmp_scfhandle_t *);
  80 static int ndmp_smf_start_transaction(ndmp_scfhandle_t *);
  81 static int ndmp_smf_end_transaction(ndmp_scfhandle_t *, boolean_t);
  82 static int ndmp_smf_set_property(ndmp_scfhandle_t *, const char *,
  83                 const char *);
  84 static int ndmp_smf_get_property(ndmp_scfhandle_t *, const char *, char *,
  85                 size_t);
  86 static int ndmp_smf_create_service_pgroup(ndmp_scfhandle_t *, const char *);
  87 static int ndmp_smf_delete_property(ndmp_scfhandle_t *, const char *);
  88 static int ndmp_smf_get_pg_name(ndmp_scfhandle_t *, const char *, char **);
  89
  90 /*
  91  * This routine send a refresh signal to ndmpd service which cause ndmpd
  92  * property table to be refeshed with current ndmpd properties value from SMF.
  93  */
  94 int
  95 ndmp_service_refresh(void)
  96 {
  97         int rc = smf_refresh_instance(NDMP_INST);
  98
  99         if (rc != 0)
 100                 ndmp_errno = ENDMP_SMF_INTERNAL;
 101         return (rc);
 102 }
 103
 104 /*
 105  * Returns value of the specified variable/property. The return value is a
 106  * string pointer to the locally allocated memory if the config param is
 107  * defined otherwise it would be NULL.
 108  */
 109 int
 110 ndmp_get_prop(const char *prop, char **value)
 111 {
 112         ndmp_scfhandle_t *handle;
 113         char *lval;
 114         char *pgname;
 115
 116         *value = NULL;
 117         if ((handle = ndmp_smf_scf_init(NDMP_GROUP_FMRI_PREFIX)) == NULL) {
 118                 return (-1);
 119         }
 120         if (ndmp_smf_get_pg_name(handle, prop, &pgname)) {
 121                 ndmp_smf_scf_fini(handle);
 122                 ndmp_errno = ENDMP_SMF_PROP_GRP;
 123                 return (-1);
 124         }
 125         if (ndmp_smf_create_service_pgroup(handle, pgname)) {
 126                 ndmp_smf_scf_fini(handle);
 127                 return (-1);
 128         }
 129         if ((lval = malloc(NDMP_PROP_LEN)) == NULL) {
 130                 ndmp_smf_scf_fini(handle);
 131                 ndmp_errno = ENDMP_MEM_ALLOC;
 132                 return (-1);
 133         }
 134         if (ndmp_smf_get_property(handle, prop, lval, NDMP_PROP_LEN) != 0) {
 135                 ndmp_smf_scf_fini(handle);
 136                 free(lval);
 137                 ndmp_errno = ENDMP_SMF_PROP;
 138                 return (-1);
 139         }
 140         *value = lval;
 141         ndmp_smf_scf_fini(handle);
 142         return (0);
 143 }
 144
 145 int
 146 ndmp_set_prop(const char *env, const char *env_val)
 147 {
 148         ndmp_scfhandle_t *handle;
 149         char *pgname;
 150         int rc;
 151
 152         if ((handle = ndmp_smf_scf_init(NDMP_GROUP_FMRI_PREFIX)) == NULL)
 153                 return (-1);
 154
 155         if (ndmp_smf_get_pg_name(handle, env, &pgname)) {
 156                 ndmp_smf_scf_fini(handle);
 157                 ndmp_errno = ENDMP_SMF_PROP_GRP;
 158                 return (-1);
 159         }
 160
 161         if (ndmp_smf_create_service_pgroup(handle, pgname)) {
 162                 ndmp_smf_scf_fini(handle);
 163                 return (-1);
 164         }
 165
 166         if (ndmp_smf_start_transaction(handle)) {
 167                 ndmp_smf_scf_fini(handle);
 168                 return (-1);
 169         }
 170
 171         if (env_val)
 172                 rc = ndmp_smf_set_property(handle, env, env_val);
 173         else
 174                 rc = ndmp_smf_delete_property(handle, env);
 175
 176         if (ndmp_config_saveenv(handle, (rc == 0)) == 0)
 177                 return (rc);
 178         else
 179                 return (-1);
 180 }
 181
 182 static int
 183 ndmp_smf_get_pg_name(ndmp_scfhandle_t *h, const char *pname, char **pgname)
 184 {
 185         scf_value_t *value;
 186         scf_property_t *prop;
 187         int i;
 188
 189         for (i = 0; i < NPG; i++) {
 190                 if (scf_service_get_pg(h->scf_service, ndmp_pg[i],
 191                     h->scf_pg) != 0)
 192                         return (-1);
 193
 194                 if ((value = scf_value_create(h->scf_handle)) == NULL)
 195                         return (-1);
 196
 197                 if ((prop = scf_property_create(h->scf_handle)) == NULL) {
 198                         scf_value_destroy(value);
 199                         return (-1);
 200                 }
 201                 /*
 202                  * This will fail if property does not exist in the property
 203                  * group. Check the next property group in case of failure.
 204                  */
 205                 if ((scf_pg_get_property(h->scf_pg, pname, prop)) != 0) {
 206                         scf_value_destroy(value);
 207                         scf_property_destroy(prop);
 208                         continue;
 209                 }
 210
 211                 *pgname = ndmp_pg[i];
 212                 scf_value_destroy(value);
 213                 scf_property_destroy(prop);
 214                 return (0);
 215         }
 216         return (-1);
 217 }
 218
 219 /*
 220  * Basically commit the transaction.
 221  */
 222 static int
 223 ndmp_config_saveenv(ndmp_scfhandle_t *handle, boolean_t commit)
 224 {
 225         int ret = 0;
 226
 227         ret = ndmp_smf_end_transaction(handle, commit);
 228
 229         ndmp_smf_scf_fini(handle);
 230         return (ret);
 231 }
 232
 233 /*
 234  * Must be called when done. Called with the handle allocated in
 235  * ndmp_smf_scf_init(), it cleans up the state and frees any SCF resources
 236  * still in use.
 237  */
 238 static void
 239 ndmp_smf_scf_fini(ndmp_scfhandle_t *handle)
 240 {
 241         if (handle == NULL)
 242                 return;
 243
 244         scf_scope_destroy(handle->scf_scope);
 245         scf_service_destroy(handle->scf_service);
 246         scf_pg_destroy(handle->scf_pg);
 247         handle->scf_state = NDMP_SCH_STATE_UNINIT;
 248         (void) scf_handle_unbind(handle->scf_handle);
 249         scf_handle_destroy(handle->scf_handle);
 250         free(handle);
 251 }
 252
 253 /*
 254  * Must be called before using any of the SCF functions. Returns
 255  * ndmp_scfhandle_t pointer if success.
 256  */
 257 static ndmp_scfhandle_t *
 258 ndmp_smf_scf_init(const char *svc_name)
 259 {
 260         ndmp_scfhandle_t *handle;
 261
 262         handle = (ndmp_scfhandle_t *)calloc(1, sizeof (ndmp_scfhandle_t));
 263         if (handle != NULL) {
 264                 handle->scf_state = NDMP_SCH_STATE_INITIALIZING;
 265                 if (((handle->scf_handle =
 266                     scf_handle_create(SCF_VERSION)) != NULL) &&
 267                     (scf_handle_bind(handle->scf_handle) == 0)) {
 268                         if ((handle->scf_scope =
 269                             scf_scope_create(handle->scf_handle)) == NULL)
 270                                 goto err;
 271
 272                         if (scf_handle_get_local_scope(handle->scf_handle,
 273                             handle->scf_scope) != 0)
 274                                 goto err;
 275
 276                         if ((handle->scf_service =
 277                             scf_service_create(handle->scf_handle)) == NULL)
 278                                 goto err;
 279
 280                         if (scf_scope_get_service(handle->scf_scope, svc_name,
 281                             handle->scf_service) != SCF_SUCCESS)
 282                                 goto err;
 283
 284                         if ((handle->scf_pg =
 285                             scf_pg_create(handle->scf_handle)) == NULL)
 286                                 goto err;
 287
 288                         handle->scf_state = NDMP_SCH_STATE_INIT;
 289                 } else {
 290                         goto err;
 291                 }
 292         } else {
 293                 ndmp_errno = ENDMP_MEM_ALLOC;
 294                 handle = NULL;
 295         }
 296         return (handle);
 297
 298         /* Error handling/unwinding */
 299 err:
 300         (void) ndmp_smf_scf_fini(handle);
 301         ndmp_errno = ENDMP_SMF_INTERNAL;
 302         return (NULL);
 303 }
 304
 305 /*
 306  * Create a new property group at service level.
 307  */
 308 static int
 309 ndmp_smf_create_service_pgroup(ndmp_scfhandle_t *handle, const char *pgroup)
 310 {
 311         int err;
 312
 313         /*
 314          * Only create a handle if it doesn't exist. It is ok to exist since
 315          * the pg handle will be set as a side effect.
 316          */
 317         if (handle->scf_pg == NULL) {
 318                 if ((handle->scf_pg =
 319                     scf_pg_create(handle->scf_handle)) == NULL) {
 320                         ndmp_errno = ENDMP_SMF_INTERNAL;
 321                         return (-1);
 322                 }
 323         }
 324
 325         /*
 326          * If the pgroup exists, we are done. If it doesn't, then we need to
 327          * actually add one to the service instance.
 328          */
 329         if (scf_service_get_pg(handle->scf_service,
 330             pgroup, handle->scf_pg) != 0) {
 331                 /* Doesn't exist so create one */
 332                 if (scf_service_add_pg(handle->scf_service, pgroup,
 333                     SCF_GROUP_FRAMEWORK, 0, handle->scf_pg) != 0) {
 334                         err = scf_error();
 335                         switch (err) {
 336                         case SCF_ERROR_PERMISSION_DENIED:
 337                                 ndmp_errno = ENDMP_SMF_PERM;
 338                                 return (-1);
 339                         default:
 340                                 ndmp_errno = ENDMP_SMF_INTERNAL;
 341                                 return (-1);
 342                         }
 343                 }
 344         }
 345         return (0);
 346 }
 347
 348 /*
 349  * Start transaction on current pg in handle. The pg could be service or
 350  * instance level. Must be called after pg handle is obtained from create or
 351  * get.
 352  */
 353 static int
 354 ndmp_smf_start_transaction(ndmp_scfhandle_t *handle)
 355 {
 356         /*
 357          * Lookup the property group and create it if it doesn't already
 358          * exist.
 359          */
 360         if (handle->scf_state == NDMP_SCH_STATE_INIT) {
 361                 if ((handle->scf_trans =
 362                     scf_transaction_create(handle->scf_handle)) != NULL) {
 363                         if (scf_transaction_start(handle->scf_trans,
 364                             handle->scf_pg) != 0) {
 365                                 scf_transaction_destroy(handle->scf_trans);
 366                                 handle->scf_trans = NULL;
 367                                 ndmp_errno = ENDMP_SMF_INTERNAL;
 368                                 return (-1);
 369                         }
 370                 } else {
 371                         ndmp_errno = ENDMP_SMF_INTERNAL;
 372                         return (-1);
 373                 }
 374         }
 375         if (scf_error() == SCF_ERROR_PERMISSION_DENIED) {
 376                 ndmp_errno = ENDMP_SMF_PERM;
 377                 return (-1);
 378         }
 379
 380         return (0);
 381 }
 382
 383 /*
 384  * Commit the changes that were added to the transaction in the handle. Do all
 385  * necessary cleanup.
 386  */
 387 static int
 388 ndmp_smf_end_transaction(ndmp_scfhandle_t *handle, boolean_t commit)
 389 {
 390         int rc = 0;
 391
 392         if (commit) {
 393                 if (scf_transaction_commit(handle->scf_trans) < 0) {
 394                         ndmp_errno = ENDMP_SMF_INTERNAL;
 395                         rc = -1;
 396                 }
 397         }
 398
 399         scf_transaction_destroy_children(handle->scf_trans);
 400         scf_transaction_destroy(handle->scf_trans);
 401         handle->scf_trans = NULL;
 402
 403         return (rc);
 404 }
 405
 406 /*
 407  * Deletes property in current pg
 408  */
 409 static int
 410 ndmp_smf_delete_property(ndmp_scfhandle_t *handle, const char *propname)
 411 {
 412         scf_transaction_entry_t *entry = NULL;
 413
 414         /*
 415          * Properties must be set in transactions and don't take effect until
 416          * the transaction has been ended/committed.
 417          */
 418         if ((entry = scf_entry_create(handle->scf_handle)) != NULL) {
 419                 if (scf_transaction_property_delete(handle->scf_trans, entry,
 420                     propname) != 0) {
 421                         scf_entry_destroy(entry);
 422                         ndmp_errno = ENDMP_SMF_INTERNAL;
 423                         return (-1);
 424                 }
 425         } else {
 426                 ndmp_errno = ENDMP_SMF_INTERNAL;
 427                 return (-1);
 428         }
 429         if ((scf_error()) == SCF_ERROR_PERMISSION_DENIED) {
 430                 ndmp_errno = ENDMP_SMF_PERM;
 431                 scf_entry_destroy(entry);
 432                 return (-1);
 433         }
 434
 435         return (0);
 436 }
 437
 438 /*
 439  * Sets property in current pg
 440  */
 441 static int
 442 ndmp_smf_set_property(ndmp_scfhandle_t *handle, const char *propname,
 443     const char *valstr)
 444 {
 445         int ret = 0;
 446         scf_value_t *value = NULL;
 447         scf_transaction_entry_t *entry = NULL;
 448         scf_property_t *prop = NULL;
 449         scf_type_t type;
 450         int64_t valint;
 451         uint8_t valbool;
 452
 453         /*
 454          * Properties must be set in transactions and don't take effect until
 455          * the transaction has been ended/committed.
 456          */
 457         if (((value = scf_value_create(handle->scf_handle)) == NULL) ||
 458             ((entry = scf_entry_create(handle->scf_handle)) == NULL) ||
 459             ((prop = scf_property_create(handle->scf_handle)) == NULL) ||
 460             (scf_pg_get_property(handle->scf_pg, propname, prop) != 0) ||
 461             (scf_property_get_value(prop, value) != 0)) {
 462                 ret = -1;
 463                 goto out;
 464         }
 465
 466         type = scf_value_type(value);
 467         if ((scf_transaction_property_change(handle->scf_trans, entry, propname,
 468             type) != 0) &&
 469             (scf_transaction_property_new(handle->scf_trans, entry, propname,
 470             type) != 0)) {
 471                 ret = -1;
 472                 goto out;
 473         }
 474
 475         switch (type) {
 476         case SCF_TYPE_ASTRING:
 477                 if ((scf_value_set_astring(value, valstr)) != SCF_SUCCESS)
 478                         ret = -1;
 479                 break;
 480         case SCF_TYPE_INTEGER:
 481                 valint = strtoll(valstr, 0, 0);
 482                 scf_value_set_integer(value, valint);
 483                 break;
 484         case SCF_TYPE_BOOLEAN:
 485                 if (strncmp(valstr, "yes", 3))
 486                         valbool = 0;
 487                 else
 488                         valbool = 1;
 489                 scf_value_set_boolean(value, valbool);
 490                 break;
 491         default:
 492                 ret = -1;
 493         }
 494         if (scf_entry_add_value(entry, value) == 0) {
 495                 /* The value is in the transaction */
 496                 value = NULL;
 497         } else {
 498                 ret = -1;
 499         }
 500         /* The entry is in the transaction */
 501         entry = NULL;
 502
 503 out:
 504         if (ret == -1) {
 505                 if ((scf_error() == SCF_ERROR_PERMISSION_DENIED))
 506                         ndmp_errno = ENDMP_SMF_PERM;
 507                 else
 508                         ndmp_errno = ENDMP_SMF_INTERNAL;
 509         }
 510         scf_property_destroy(prop);
 511         scf_value_destroy(value);
 512         scf_entry_destroy(entry);
 513         return (ret);
 514 }
 515
 516 /*
 517  * Gets a property value.upto sz size. Caller is responsible to have enough
 518  * memory allocated.
 519  */
 520 static int
 521 ndmp_smf_get_property(ndmp_scfhandle_t *handle, const char *propname,
 522     char *valstr, size_t sz)
 523 {
 524         int ret = 0;
 525         scf_value_t *value = NULL;
 526         scf_property_t *prop = NULL;
 527         scf_type_t type;
 528         int64_t valint;
 529         uint8_t valbool;
 530         char valstrbuf[NDMP_PROP_LEN];
 531
 532         if (((value = scf_value_create(handle->scf_handle)) != NULL) &&
 533             ((prop = scf_property_create(handle->scf_handle)) != NULL) &&
 534             (scf_pg_get_property(handle->scf_pg, propname, prop) == 0)) {
 535                 if (scf_property_get_value(prop, value) == 0) {
 536                         type = scf_value_type(value);
 537                         switch (type) {
 538                         case SCF_TYPE_ASTRING:
 539                                 if (scf_value_get_astring(value, valstr,
 540                                     sz) < 0) {
 541                                         ret = -1;
 542                                 }
 543                                 break;
 544                         case SCF_TYPE_INTEGER:
 545                                 if (scf_value_get_integer(value,
 546                                     &valint) != 0) {
 547                                         ret = -1;
 548                                         break;
 549                                 }
 550                                 valstrbuf[NDMP_PROP_LEN - 1] = '\0';
 551                                 (void) strncpy(valstr, lltostr(valint,
 552                                     &valstrbuf[NDMP_PROP_LEN - 1]),
 553                                     NDMP_PROP_LEN);
 554                                 break;
 555                         case SCF_TYPE_BOOLEAN:
 556                                 if (scf_value_get_boolean(value,
 557                                     &valbool) != 0) {
 558                                         ret = -1;
 559                                         break;
 560                                 }
 561                                 if (valbool == 1)
 562                                         (void) strncpy(valstr, "yes", 4);
 563                                 else
 564                                         (void) strncpy(valstr, "no", 3);
 565                                 break;
 566                         default:
 567                                 ret = -1;
 568                         }
 569                 } else {
 570                         ret = -1;
 571                 }
 572         } else {
 573                 ret = -1;
 574         }
 575         scf_value_destroy(value);
 576         scf_property_destroy(prop);
 577         return (ret);
 578 }