usr/src/lib/libshare/smbfs/libshare_smbfs.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 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * SMB specific functions
  29  */
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <zone.h>
  36 #include <errno.h>
  37 #include <locale.h>
  38 #include <signal.h>
  39 #include <fcntl.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <syslog.h>
  43 #include "libshare.h"
  44 #include "libshare_impl.h"
  45 #include <pwd.h>
  46 #include <limits.h>
  47 #include <libscf.h>
  48 #include <strings.h>
  49 #include "libshare_smbfs.h"
  50 #include <rpcsvc/daemon_utils.h>
  51 #include <arpa/inet.h>
  52 #include <uuid/uuid.h>
  53 #include <netsmb/smb_lib.h>
  54
  55 #define SMBFS_PROTOCOL_NAME     "smbfs"
  56
  57 /* internal functions */
  58 static uint64_t smbfs_features();
  59 static int smbfs_init();
  60 static void smbfs_fini();
  61 static int smbfs_set_proto_prop(sa_property_t);
  62 static sa_protocol_properties_t smbfs_get_proto_set();
  63 static char *smbfs_get_status();
  64 static int smbfs_delete_section(char *);
  65 static int smbfs_delete_property_group(char *);
  66
  67 static int range_check_validator(int, char *, char *);
  68 static int string_length_check_validator(int, char *, char *);
  69 static int yes_no_validator(int, char *, char *);
  70 static int ip_address_validator(int, char *, char *);
  71 static int minauth_validator(int, char *, char *);
  72 static int password_validator(int, char *, char *);
  73 static int signing_validator(int, char *, char *);
  74
  75 int propset_changed = 0;
  76
  77 /*
  78  * ops vector that provides the protocol specific info and operations
  79  * for share management.
  80  */
  81
  82 struct sa_plugin_ops sa_plugin_ops = {
  83         SA_PLUGIN_VERSION,
  84         SMBFS_PROTOCOL_NAME,
  85         smbfs_init,
  86         smbfs_fini,
  87         NULL,   /* share */
  88         NULL,   /* unshare */
  89         NULL,   /* valid_prop */
  90         NULL,   /* valid_space */
  91         NULL,   /* security_prop */
  92         NULL,   /* legacy_opts */
  93         NULL,   /* legacy_format */
  94         smbfs_set_proto_prop,
  95         smbfs_get_proto_set,
  96         smbfs_get_status,
  97         NULL,   /* space_alias */
  98         NULL,   /* update_legacy */
  99         NULL,   /* delete_legacy */
 100         NULL,   /* change_notify */
 101         NULL,   /* enable_resource */
 102         NULL,   /* disable_resource */
 103         smbfs_features,
 104         NULL,   /* get_transient_shares */
 105         NULL,   /* notify_resource */
 106         NULL,   /* rename_resource */
 107         NULL,   /* run_command */
 108         NULL,   /* command_help */
 109         smbfs_delete_section,
 110 };
 111
 112 /*
 113  * is_a_number(number)
 114  *
 115  * is the string a number in one of the forms we want to use?
 116  */
 117
 118 static int
 119 is_a_number(char *number)
 120 {
 121         int ret = 1;
 122         int hex = 0;
 123
 124         if (strncmp(number, "0x", 2) == 0) {
 125                 number += 2;
 126                 hex = 1;
 127         } else if (*number == '-') {
 128                 number++; /* skip the minus */
 129         }
 130
 131         while (ret == 1 && *number != '\0') {
 132                 if (hex) {
 133                         ret = isxdigit(*number++);
 134                 } else {
 135                         ret = isdigit(*number++);
 136                 }
 137         }
 138         return (ret);
 139 }
 140
 141 /*
 142  * Protocol management functions
 143  *
 144  * properties defined in the default files are defined in
 145  * proto_option_defs for parsing and validation.
 146  */
 147
 148 struct smbclnt_proto_option_defs smbclnt_proto_options[] = {
 149         { "section", NULL, PROTO_OPT_SECTION,
 150             0, 0, MAX_VALUE_BUFLEN,
 151             string_length_check_validator},
 152         { "addr", NULL, PROTO_OPT_ADDR,
 153             0, 0, MAX_VALUE_BUFLEN,
 154             ip_address_validator},
 155         { "minauth", NULL, PROTO_OPT_MINAUTH,
 156             0, 0, MAX_VALUE_BUFLEN,
 157             minauth_validator},
 158         { "nbns_broadcast", NULL, PROTO_OPT_NBNS_BROADCAST,
 159             0, 0, 0,
 160             yes_no_validator},
 161         { "nbns_enable", NULL, PROTO_OPT_NBNS_ENABLE,
 162             0, 0, 0,
 163             yes_no_validator},
 164         { "nbns", NULL, PROTO_OPT_NBNSADDR,
 165             0, 0, MAX_VALUE_BUFLEN,
 166             ip_address_validator},
 167         { "password", NULL, PROTO_OPT_PASSWORD,
 168             0, 0, MAX_VALUE_BUFLEN,
 169             password_validator},
 170         { "timeout", NULL, PROTO_OPT_TIMEOUT,
 171             0, 0, 60,
 172             range_check_validator},
 173         { "user", NULL, PROTO_OPT_USER,
 174             0, 0, MAX_VALUE_BUFLEN,
 175             string_length_check_validator},
 176         { "domain", NULL, PROTO_OPT_DOMAIN,
 177             0, 0, MAX_VALUE_BUFLEN,
 178             string_length_check_validator},
 179         { "workgroup", NULL, PROTO_OPT_WORKGROUP,
 180             0, 0, MAX_VALUE_BUFLEN,
 181             string_length_check_validator},
 182         { "signing", NULL, PROTO_OPT_SIGNING,
 183             0, 0, MAX_VALUE_BUFLEN,
 184             signing_validator},
 185         {NULL}
 186 };
 187
 188 /*
 189  * Check the range of value as int range.
 190  */
 191 /*ARGSUSED*/
 192 static int
 193 range_check_validator(int index, char *section, char *value)
 194 {
 195         int ret = SA_OK;
 196
 197         if (value == NULL)
 198                 return (SA_BAD_VALUE);
 199         if (strlen(value) == 0)
 200                 return (SA_OK);
 201         if (!is_a_number(value)) {
 202                 ret = SA_BAD_VALUE;
 203         } else {
 204                 int val;
 205                 val = strtoul(value, NULL, 0);
 206                 if (val < smbclnt_proto_options[index].minval ||
 207                     val > smbclnt_proto_options[index].maxval)
 208                         ret = SA_BAD_VALUE;
 209         }
 210         return (ret);
 211 }
 212
 213 /*
 214  * Check the length of the string
 215  */
 216 /*ARGSUSED*/
 217 static int
 218 string_length_check_validator(int index, char *section, char *value)
 219 {
 220         int ret = SA_OK;
 221
 222         if (value == NULL)
 223                 return (SA_BAD_VALUE);
 224         if (strlen(value) == 0)
 225                 return (SA_OK);
 226         if (strlen(value) > smbclnt_proto_options[index].maxval)
 227                 ret = SA_BAD_VALUE;
 228         return (ret);
 229 }
 230
 231 /*
 232  * Check yes/no
 233  */
 234 /*ARGSUSED*/
 235 static int
 236 yes_no_validator(int index, char *section, char *value)
 237 {
 238         if (value == NULL)
 239                 return (SA_BAD_VALUE);
 240         if (strlen(value) == 0)
 241                 return (SA_OK);
 242         if ((strcasecmp(value, "yes") == 0) ||
 243             (strcasecmp(value, "no") == 0) ||
 244             (strcasecmp(value, "true") == 0) ||
 245             (strcasecmp(value, "false") == 0))
 246                 return (SA_OK);
 247         return (SA_BAD_VALUE);
 248 }
 249
 250 /*
 251  * Check IP address.
 252  */
 253 /*ARGSUSED*/
 254 static int
 255 ip_address_validator(int index, char *section, char *value)
 256 {
 257         int len;
 258
 259         if (value == NULL)
 260                 return (SA_BAD_VALUE);
 261         len = strlen(value);
 262         if (len == 0)
 263                 return (SA_OK);
 264         if (len > MAX_VALUE_BUFLEN)
 265                 return (SA_BAD_VALUE);
 266         return (SA_OK);
 267 }
 268
 269 /*ARGSUSED*/
 270 static int
 271 minauth_validator(int index, char *section, char *value)
 272 {
 273         if (value == NULL)
 274                 return (SA_BAD_VALUE);
 275         if (strlen(value) == 0)
 276                 return (SA_OK);
 277         if (strcmp(value, "kerberos") == 0 ||
 278             strcmp(value, "ntlmv2") == 0 ||
 279             strcmp(value, "ntlm") == 0 ||
 280             strcmp(value, "lm") == 0 ||
 281             strcmp(value, "none") == 0)
 282                 return (SA_OK);
 283         else
 284                 return (SA_BAD_VALUE);
 285 }
 286
 287 /*ARGSUSED*/
 288 static int
 289 signing_validator(int index, char *section, char *value)
 290 {
 291         if (value == NULL)
 292                 return (SA_BAD_VALUE);
 293         if (strlen(value) == 0)
 294                 return (SA_OK);
 295         if (strcmp(value, "disabled") == 0 ||
 296             strcmp(value, "enabled") == 0 ||
 297             strcmp(value, "required") == 0)
 298                 return (SA_OK);
 299         else
 300                 return (SA_BAD_VALUE);
 301 }
 302
 303 /*ARGSUSED*/
 304 static int
 305 password_validator(int index, char *section, char *value)
 306 {
 307         char buffer[100];
 308
 309         /* mangled passwords will start with this pattern */
 310         if (strlen(value) == 0)
 311                 return (SA_OK);
 312         if (strncmp(value, "$$1", 3) != 0)
 313                 return (SA_PASSWORD_ENC);
 314         if (smb_simpledecrypt(buffer, value) != 0)
 315                 return (SA_BAD_VALUE);
 316         return (SA_OK);
 317 }
 318
 319
 320 /*
 321  * the protoset holds the defined options so we don't have to read
 322  * them multiple times
 323  */
 324 sa_protocol_properties_t protoset;
 325
 326 static int
 327 findprotoopt(char *name)
 328 {
 329         int i;
 330         for (i = 0; smbclnt_proto_options[i].name != NULL; i++) {
 331                 if (strcasecmp(smbclnt_proto_options[i].name, name) == 0)
 332                         return (i);
 333         }
 334         return (-1);
 335 }
 336
 337 /*
 338  * Load the persistent settings from SMF.  Each section is an SMF
 339  * property group with an "S-" prefix and a UUID, and the section
 340  * is itself a property which can have a more flexible name than
 341  * a property group name can have.  The section name need not be
 342  * the first property, so we have to be a little flexible, but
 343  * the change of name of the property groups is a reliable way
 344  * to know that we're seeing a different section.
 345  */
 346 int
 347 smbclnt_config_load()
 348 {
 349         scf_simple_app_props_t *props = NULL;
 350         scf_simple_prop_t *prop = NULL, *lastprop = NULL;
 351         char *lastpgname = NULL, *pgname = NULL;
 352         char *name = NULL, *value = NULL;
 353         sa_property_t sect, node;
 354
 355         props = scf_simple_app_props_get(NULL, SMBC_DEFAULT_INSTANCE_FMRI);
 356         if (props == NULL)
 357                 return (-1);
 358
 359         for (;;) {
 360                 lastprop = prop;
 361                 prop = (scf_simple_prop_t *)
 362                     scf_simple_app_props_next(props, lastprop);
 363                 if (prop == NULL)
 364                         break;
 365
 366                 /* Ignore properties that don't have our prefix */
 367                 pgname = scf_simple_prop_pgname(prop);
 368                 if (strncmp("S-", pgname, 2) != 0)
 369                         continue;
 370
 371                 /*
 372                  * Note property group name changes, which mark sections
 373                  *
 374                  * The memory allocated by sa_create_section is
 375                  * linked into the list of children under protoset,
 376                  * and will eventually be freed via that list.
 377                  */
 378                 if (lastpgname == NULL || strcmp(lastpgname, pgname) != 0) {
 379                         sect = sa_create_section(NULL, pgname+2);
 380                         (void) xmlSetProp(sect, (xmlChar *)"type",
 381                             (xmlChar *)SMBFS_PROTOCOL_NAME);
 382                         (void) sa_add_protocol_property(protoset, sect);
 383                         if (lastpgname)
 384                                 free(lastpgname);
 385                         lastpgname = strdup(pgname);
 386                 }
 387                 name = scf_simple_prop_name(prop);
 388                 value = scf_simple_prop_next_astring(prop);
 389
 390                 /* If we get a section name, apply it and consume it */
 391                 if (strncmp("section", name, 7) == 0 && value != NULL) {
 392                         (void) xmlSetProp(sect, (xmlChar *)"name",
 393                             (xmlChar *)value);
 394                         continue;
 395                 }
 396
 397                 /*
 398                  * We have an ordinary property.  Add to the section.
 399                  *
 400                  * The memory allocated by sa_create_property is
 401                  * linked into the list of children under "sect",
 402                  * and will eventually be freed via that list.
 403                  */
 404                 node = sa_create_property(name, value);
 405                 (void) sa_add_protocol_property(sect, node);
 406         }
 407         scf_simple_app_props_free(props);
 408
 409         if (lastpgname)
 410                 free(lastpgname);
 411         return (0);
 412 }
 413
 414 /*
 415  * Save the set of properties for a particular section, which is
 416  * stored as a single property group.  Properties will have been
 417  * changed earlier by one or more calls to smbfs_save_property(),
 418  * which only set the value in our array and marked them as
 419  * SMBC_MODIFIED.
 420  */
 421 int
 422 smbfs_save_propset()
 423 {
 424         smb_scfhandle_t *handle = NULL;
 425         char propgroup[256];
 426         char *section = smbclnt_proto_options[PROTO_OPT_SECTION].value;
 427         char *uu = NULL;
 428         uuid_t uuid;
 429         int i, ret = 0;
 430         sa_property_t propset;
 431         int new = 0, nonnull = 0;
 432
 433         propset = sa_get_protocol_section(protoset, section);
 434         (void) strlcpy(propgroup, SMBC_PG_PREFIX, sizeof (propgroup));
 435         propgroup[SMBC_PG_PREFIX_LEN] = '\0';
 436         uu = sa_get_property_attr(propset, "extra");
 437         if (uu != NULL) {
 438                 (void) strlcat(propgroup, uu, sizeof (propgroup));
 439                 free(uu);
 440         } else {
 441                 new = 1;
 442                 smbclnt_proto_options[PROTO_OPT_SECTION].flags |= SMBC_MODIFIED;
 443                 uuid_generate(uuid);
 444                 uuid_unparse(uuid, &propgroup[SMBC_PG_PREFIX_LEN]);
 445         }
 446
 447         handle = smb_smf_scf_init(SMBC_FMRI_PREFIX);
 448         if (handle == NULL) {
 449                 return (1);
 450         }
 451
 452         if ((ret = smb_smf_instance_create(handle, SMBC_FMRI_PREFIX,
 453             SMBC_PG_INSTANCE)) != SMBC_SMF_OK) {
 454                 goto out;
 455         }
 456
 457         if ((ret = smb_smf_create_instance_pgroup(handle, propgroup))
 458             != SMBC_SMF_OK) {
 459                 goto out;
 460         }
 461
 462         if ((ret = smb_smf_start_transaction(handle)) != SMBC_SMF_OK) {
 463                 goto out;
 464         }
 465
 466         for (i = PROTO_OPT_SECTION+1; i <= SMBC_OPT_MAX; i++) {
 467                 if ((smbclnt_proto_options[i].flags & SMBC_MODIFIED) == 0)
 468                         continue;
 469                 if (strcmp(smbclnt_proto_options[i].value, "") == 0)
 470                         ret = smb_smf_delete_property(handle,
 471                             smbclnt_proto_options[i].name);
 472                 else {
 473                         ret = smb_smf_set_string_property(handle,
 474                             smbclnt_proto_options[i].name,
 475                             smbclnt_proto_options[i].value);
 476                         nonnull = 1;
 477                 }
 478                 free(smbclnt_proto_options[i].value);
 479                 smbclnt_proto_options[i].value = NULL;
 480                 smbclnt_proto_options[i].flags &= ~SMBC_MODIFIED;
 481                 if (ret != SMBC_SMF_OK)
 482                         goto outtrans;
 483         }
 484         /*
 485          * Suppress new, null entries by not saving the section name.
 486          */
 487         if (!new || nonnull) {
 488                 ret = smb_smf_set_string_property(handle,
 489                     smbclnt_proto_options[PROTO_OPT_SECTION].name,
 490                     smbclnt_proto_options[PROTO_OPT_SECTION].value);
 491                 free(smbclnt_proto_options[PROTO_OPT_SECTION].value);
 492                 smbclnt_proto_options[PROTO_OPT_SECTION].value = NULL;
 493                 smbclnt_proto_options[PROTO_OPT_SECTION].flags &=
 494                     ~SMBC_MODIFIED;
 495         }
 496         propset_changed = 0;
 497
 498 outtrans:
 499         ret = smb_smf_end_transaction(handle);
 500 out:
 501         smb_smf_scf_fini(handle);
 502         return (ret);
 503 }
 504
 505 /*
 506  * initprotofromdefault()
 507  *
 508  * read the default file(s) and add the defined values to the
 509  * protoset.  Note that default values are known from the built in
 510  * table in case the file doesn't have a definition.
 511  */
 512
 513 static int
 514 initprotofromdefault()
 515 {
 516         protoset = sa_create_protocol_properties(SMBFS_PROTOCOL_NAME);
 517         if (protoset == NULL)
 518                 return (SA_NO_MEMORY);
 519         if (smbclnt_config_load() != 0)
 520                 return (SA_OK);
 521
 522         return (SA_OK);
 523 }
 524
 525 /*
 526  *
 527  * smbfs_features()
 528  *
 529  * Report the plugin's features
 530  */
 531 static uint64_t
 532 smbfs_features()
 533 {
 534         return (SA_FEATURE_HAS_SECTIONS | SA_FEATURE_ADD_PROPERTIES);
 535 }
 536
 537 /*
 538  * smbfs_init()
 539  *
 540  * Initialize the smb plugin.
 541  */
 542
 543 static int
 544 smbfs_init()
 545 {
 546         int ret = SA_OK;
 547
 548         if (sa_plugin_ops.sa_init != smbfs_init) {
 549                 return (SA_SYSTEM_ERR);
 550         }
 551
 552         if (initprotofromdefault() != SA_OK) {
 553                 return (SA_SYSTEM_ERR);
 554         }
 555
 556         return (ret);
 557 }
 558
 559 /*
 560  * smbfs_fini()
 561  *
 562  * uninitialize the smb plugin. Want to avoid memory leaks.
 563  */
 564
 565 static void
 566 smbfs_fini()
 567 {
 568         if (propset_changed)
 569                 (void) smbfs_save_propset();
 570         xmlFreeNode(protoset);
 571         protoset = NULL;
 572 }
 573
 574 /*
 575  * smbfs_get_proto_set()
 576  *
 577  * Return an optionset with all the protocol specific properties in
 578  * it.
 579  */
 580
 581 static sa_protocol_properties_t
 582 smbfs_get_proto_set()
 583 {
 584         return (protoset);
 585 }
 586
 587 /*
 588  * smbfs_validate_proto_prop(index, name, value)
 589  *
 590  * Verify that the property specifed by name can take the new
 591  * value. This is a sanity check to prevent bad values getting into
 592  * the default files.
 593  */
 594 static int
 595 smbfs_validate_proto_prop(int index, char *section, char *name, char *value)
 596 {
 597         if ((section == NULL) || (name == NULL) || (index < 0))
 598                 return (SA_BAD_VALUE);
 599
 600         if (smbclnt_proto_options[index].validator == NULL)
 601                 return (SA_OK);
 602
 603         return (smbclnt_proto_options[index].validator(index, section, value));
 604 }
 605
 606 /*
 607  * Save a property to our array; it will be stored to SMF later by
 608  * smbfs_save_propset().
 609  */
 610 int
 611 smbfs_save_property(int index, char *section, char *value)
 612 {
 613         char *s;
 614
 615         if (index == PROTO_OPT_WORKGROUP) {
 616                 index = PROTO_OPT_DOMAIN;
 617         }
 618         propset_changed = 1;
 619         s = strdup(section);
 620         if (s == NULL)
 621                 return (-1);
 622         smbclnt_proto_options[PROTO_OPT_SECTION].value = s;
 623         s = strdup(value);
 624         if (s == NULL)
 625                 return (-1);
 626         smbclnt_proto_options[index].value = s;
 627         smbclnt_proto_options[index].flags |= SMBC_MODIFIED;
 628         return (0);
 629 }
 630
 631 /*
 632  * smbfs_set_proto_prop(prop)
 633  *
 634  * check that prop is valid.
 635  */
 636 /*ARGSUSED*/
 637 static int
 638 smbfs_set_proto_prop(sa_property_t prop)
 639 {
 640         int ret = SA_OK;
 641         char *name;
 642         char *value;
 643         char *section;
 644         int i = -1;
 645
 646         section = sa_get_property_attr(prop, "section");
 647         if (section == NULL)
 648                 return (SA_NO_SECTION);
 649         name = sa_get_property_attr(prop, "type");
 650         value = sa_get_property_attr(prop, "value");
 651         if (name != NULL && value != NULL) {
 652                 i = findprotoopt(name);
 653                 if (i >= 0) {
 654                         ret = smbfs_validate_proto_prop(i, section,
 655                             name, value);
 656                         if (ret == SA_OK) {
 657                                 if (smbfs_save_property(i, section,
 658                                     value) != 0) {
 659                                         ret = SA_SYSTEM_ERR;
 660                                         errno = EIO;
 661                                 }
 662                         }
 663                 } else
 664                         ret = SA_INVALID_NAME;
 665         }
 666         if (name != NULL)
 667                 sa_free_attr_string(name);
 668         if (value != NULL)
 669                 sa_free_attr_string(value);
 670         if (section != NULL)
 671                 sa_free_attr_string(section);
 672
 673         return (ret);
 674 }
 675
 676 /*
 677  * smbfs_get_status()
 678  *
 679  * What is the current status of the smbd? We use the SMF state here.
 680  * Caller must free the returned value.
 681  */
 682
 683 static char *
 684 smbfs_get_status()
 685 {
 686         return (smf_get_state(SMBC_DEFAULT_INSTANCE_FMRI));
 687 }
 688
 689 /*
 690  * Delete a section by its name, which we will have read into an
 691  * XML optionset above.  We need to find it and find its UUID to
 692  * be able to generate the property group name in order to call
 693  * smbfs_delete_property_group().
 694  */
 695 static int
 696 smbfs_delete_section(char *section)
 697 {
 698         char propgroup[256];
 699         char *uu = NULL;
 700         sa_property_t propset;
 701         int ret = SA_SYSTEM_ERR;
 702
 703         propset = sa_get_protocol_section(protoset, section);
 704         (void) strlcpy(propgroup, SMBC_PG_PREFIX, sizeof (propgroup));
 705         propgroup[SMBC_PG_PREFIX_LEN] = '\0';
 706         uu = sa_get_property_attr(propset, "extra");
 707         if (uu == NULL)
 708                 goto out;
 709         (void) strlcat(propgroup, uu, sizeof (propgroup));
 710         free(uu);
 711         if ((ret = smbfs_delete_property_group(propgroup)) != SMBC_SMF_OK)
 712                 goto out;
 713         ret = SA_OK;
 714 out:
 715         return (ret);
 716 }
 717
 718 /*
 719  * Delete a property group by its name.  Called to do a 'delsect'
 720  * or called when smbclnt_config_load() notices an empty section
 721  * at the end of the properties.
 722  */
 723 static int
 724 smbfs_delete_property_group(char *propgroup)
 725 {
 726         smb_scfhandle_t *handle = NULL;
 727         int ret = SA_SYSTEM_ERR;
 728
 729         handle = smb_smf_scf_init(SMBC_FMRI_PREFIX);
 730         if (handle == NULL)
 731                 goto out;
 732
 733         if ((ret = smb_smf_instance_create(handle, SMBC_FMRI_PREFIX,
 734             SMBC_PG_INSTANCE)) != SMBC_SMF_OK)
 735                 goto out;
 736
 737         if ((ret = smb_smf_delete_instance_pgroup(handle, propgroup))
 738             != SMBC_SMF_OK)
 739                 goto out;
 740         ret = SA_OK;
 741 out:
 742         smb_smf_scf_fini(handle);
 743         return (ret);
 744 }