1da6c28aaSamw /* 2da6c28aaSamw * CDDL HEADER START 3da6c28aaSamw * 4da6c28aaSamw * The contents of this file are subject to the terms of the 5da6c28aaSamw * Common Development and Distribution License (the "License"). 6da6c28aaSamw * You may not use this file except in compliance with the License. 7da6c28aaSamw * 8da6c28aaSamw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9da6c28aaSamw * or http://www.opensolaris.org/os/licensing. 10da6c28aaSamw * See the License for the specific language governing permissions 11da6c28aaSamw * and limitations under the License. 12da6c28aaSamw * 13da6c28aaSamw * When distributing Covered Code, include this CDDL HEADER in each 14da6c28aaSamw * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15da6c28aaSamw * If applicable, add the following below this CDDL HEADER, with the 16da6c28aaSamw * fields enclosed by brackets "[]" replaced with your own identifying 17da6c28aaSamw * information: Portions Copyright [yyyy] [name of copyright owner] 18da6c28aaSamw * 19da6c28aaSamw * CDDL HEADER END 20da6c28aaSamw */ 21da6c28aaSamw /* 22148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23*ef4cfbfdSMatt Barden * Copyright 2017 Nexenta Systems, Inc. All rights reserved. 24da6c28aaSamw */ 25da6c28aaSamw 26da6c28aaSamw /* 27da6c28aaSamw * This module contains smbadm CLI which offers smb configuration 28da6c28aaSamw * functionalities. 29da6c28aaSamw */ 308d7e4166Sjose borrego #include <errno.h> 318d7e4166Sjose borrego #include <err.h> 328d7e4166Sjose borrego #include <ctype.h> 33da6c28aaSamw #include <stdlib.h> 3496a62adaSjoyce mcintosh #include <unistd.h> 35da6c28aaSamw #include <stdio.h> 36da6c28aaSamw #include <syslog.h> 37da6c28aaSamw #include <strings.h> 38da6c28aaSamw #include <limits.h> 39da6c28aaSamw #include <getopt.h> 40da6c28aaSamw #include <libintl.h> 41da6c28aaSamw #include <zone.h> 4296a62adaSjoyce mcintosh #include <pwd.h> 43da6c28aaSamw #include <grp.h> 44da6c28aaSamw #include <libgen.h> 45c8ec8eeaSjose borrego #include <netinet/in.h> 4696a62adaSjoyce mcintosh #include <auth_attr.h> 4796a62adaSjoyce mcintosh #include <locale.h> 48da6c28aaSamw #include <smbsrv/libsmb.h> 49b3700b07SGordon Ross #include <smbsrv/libsmbns.h> 50da6c28aaSamw 5196a62adaSjoyce mcintosh #if !defined(TEXT_DOMAIN) 5296a62adaSjoyce mcintosh #define TEXT_DOMAIN "SYS_TEST" 5396a62adaSjoyce mcintosh #endif 5496a62adaSjoyce mcintosh 55da6c28aaSamw typedef enum { 56da6c28aaSamw HELP_ADD_MEMBER, 57da6c28aaSamw HELP_CREATE, 58da6c28aaSamw HELP_DELETE, 59da6c28aaSamw HELP_DEL_MEMBER, 60da6c28aaSamw HELP_GET, 61da6c28aaSamw HELP_JOIN, 62da6c28aaSamw HELP_LIST, 6336a00406SGordon Ross HELP_LOOKUP, 64da6c28aaSamw HELP_RENAME, 65da6c28aaSamw HELP_SET, 66da6c28aaSamw HELP_SHOW, 673db3f65cSamw HELP_USER_DISABLE, 68*ef4cfbfdSMatt Barden HELP_USER_ENABLE, 69*ef4cfbfdSMatt Barden HELP_USER_DELETE 70da6c28aaSamw } smbadm_help_t; 71da6c28aaSamw 7296a62adaSjoyce mcintosh #define SMBADM_CMDF_NONE 0x00 733db3f65cSamw #define SMBADM_CMDF_USER 0x01 743db3f65cSamw #define SMBADM_CMDF_GROUP 0x02 753db3f65cSamw #define SMBADM_CMDF_TYPEMASK 0x0F 76faa1795aSjb 7736a00406SGordon Ross typedef enum { 7836a00406SGordon Ross SMBADM_GRP_ADDMEMBER = 0, 7936a00406SGordon Ross SMBADM_GRP_DELMEMBER, 8036a00406SGordon Ross } smbadm_grp_action_t; 8136a00406SGordon Ross 82c8ec8eeaSjose borrego #define SMBADM_ANSBUFSIZ 64 83c8ec8eeaSjose borrego 84da6c28aaSamw typedef struct smbadm_cmdinfo { 85da6c28aaSamw char *name; 86da6c28aaSamw int (*func)(int, char **); 87da6c28aaSamw smbadm_help_t usage; 88faa1795aSjb uint32_t flags; 8996a62adaSjoyce mcintosh char *auth; 90da6c28aaSamw } smbadm_cmdinfo_t; 91da6c28aaSamw 92da6c28aaSamw smbadm_cmdinfo_t *curcmd; 93da6c28aaSamw static char *progname; 94da6c28aaSamw 9596a62adaSjoyce mcintosh #define SMBADM_ACTION_AUTH "solaris.smf.manage.smb" 9696a62adaSjoyce mcintosh #define SMBADM_VALUE_AUTH "solaris.smf.value.smb" 9796a62adaSjoyce mcintosh #define SMBADM_BASIC_AUTH "solaris.network.hosts.read" 9896a62adaSjoyce mcintosh 9996a62adaSjoyce mcintosh static boolean_t smbadm_checkauth(const char *); 10096a62adaSjoyce mcintosh 1018d7e4166Sjose borrego static void smbadm_usage(boolean_t); 102b3700b07SGordon Ross static int smbadm_join_workgroup(const char *, boolean_t); 103b3700b07SGordon Ross static int smbadm_join_domain(const char *, const char *, boolean_t); 1048d7e4166Sjose borrego static void smbadm_extract_domain(char *, char **, char **); 1058d7e4166Sjose borrego 106da6c28aaSamw static int smbadm_join(int, char **); 107da6c28aaSamw static int smbadm_list(int, char **); 10836a00406SGordon Ross static int smbadm_lookup(int, char **); 10936a00406SGordon Ross static void smbadm_lookup_name(char *); 11036a00406SGordon Ross static void smbadm_lookup_sid(char *); 111da6c28aaSamw static int smbadm_group_create(int, char **); 112da6c28aaSamw static int smbadm_group_delete(int, char **); 113da6c28aaSamw static int smbadm_group_rename(int, char **); 114da6c28aaSamw static int smbadm_group_show(int, char **); 115fe1c642dSBill Krier static void smbadm_group_show_name(const char *, const char *); 116da6c28aaSamw static int smbadm_group_getprop(int, char **); 117da6c28aaSamw static int smbadm_group_setprop(int, char **); 118da6c28aaSamw static int smbadm_group_addmember(int, char **); 119da6c28aaSamw static int smbadm_group_delmember(int, char **); 12036a00406SGordon Ross static int smbadm_group_add_del_member(char *, char *, smbadm_grp_action_t); 12136a00406SGordon Ross 122*ef4cfbfdSMatt Barden static int smbadm_user_delete(int, char **); 123da6c28aaSamw static int smbadm_user_disable(int, char **); 124da6c28aaSamw static int smbadm_user_enable(int, char **); 125da6c28aaSamw 126da6c28aaSamw static smbadm_cmdinfo_t smbadm_cmdtable[] = 127da6c28aaSamw { 128faa1795aSjb { "add-member", smbadm_group_addmember, HELP_ADD_MEMBER, 12996a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 130faa1795aSjb { "create", smbadm_group_create, HELP_CREATE, 13196a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 132faa1795aSjb { "delete", smbadm_group_delete, HELP_DELETE, 13396a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 134*ef4cfbfdSMatt Barden { "delete-user", smbadm_user_delete, HELP_USER_DELETE, 135*ef4cfbfdSMatt Barden SMBADM_CMDF_USER, SMBADM_ACTION_AUTH }, 1363db3f65cSamw { "disable-user", smbadm_user_disable, HELP_USER_DISABLE, 13796a62adaSjoyce mcintosh SMBADM_CMDF_USER, SMBADM_ACTION_AUTH }, 1383db3f65cSamw { "enable-user", smbadm_user_enable, HELP_USER_ENABLE, 13996a62adaSjoyce mcintosh SMBADM_CMDF_USER, SMBADM_ACTION_AUTH }, 140faa1795aSjb { "get", smbadm_group_getprop, HELP_GET, 14196a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 14296a62adaSjoyce mcintosh { "join", smbadm_join, HELP_JOIN, 14396a62adaSjoyce mcintosh SMBADM_CMDF_NONE, SMBADM_VALUE_AUTH }, 14496a62adaSjoyce mcintosh { "list", smbadm_list, HELP_LIST, 14596a62adaSjoyce mcintosh SMBADM_CMDF_NONE, SMBADM_BASIC_AUTH }, 14636a00406SGordon Ross { "lookup", smbadm_lookup, HELP_LOOKUP, 14736a00406SGordon Ross SMBADM_CMDF_NONE, SMBADM_BASIC_AUTH }, 148faa1795aSjb { "remove-member", smbadm_group_delmember, HELP_DEL_MEMBER, 14996a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 150faa1795aSjb { "rename", smbadm_group_rename, HELP_RENAME, 15196a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 152faa1795aSjb { "set", smbadm_group_setprop, HELP_SET, 15396a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 154faa1795aSjb { "show", smbadm_group_show, HELP_SHOW, 15596a62adaSjoyce mcintosh SMBADM_CMDF_GROUP, SMBADM_ACTION_AUTH }, 156da6c28aaSamw }; 157da6c28aaSamw 158da6c28aaSamw #define SMBADM_NCMD (sizeof (smbadm_cmdtable) / sizeof (smbadm_cmdtable[0])) 159da6c28aaSamw 160da6c28aaSamw typedef struct smbadm_prop { 161da6c28aaSamw char *p_name; 162da6c28aaSamw char *p_value; 163da6c28aaSamw } smbadm_prop_t; 164da6c28aaSamw 165da6c28aaSamw typedef struct smbadm_prop_handle { 166da6c28aaSamw char *p_name; 167da6c28aaSamw char *p_dispvalue; 168da6c28aaSamw int (*p_setfn)(char *, smbadm_prop_t *); 169da6c28aaSamw int (*p_getfn)(char *, smbadm_prop_t *); 170da6c28aaSamw boolean_t (*p_chkfn)(smbadm_prop_t *); 171da6c28aaSamw } smbadm_prop_handle_t; 172da6c28aaSamw 173da6c28aaSamw static boolean_t smbadm_prop_validate(smbadm_prop_t *prop, boolean_t chkval); 174da6c28aaSamw static int smbadm_prop_parse(char *arg, smbadm_prop_t *prop); 175da6c28aaSamw static smbadm_prop_handle_t *smbadm_prop_gethandle(char *pname); 176da6c28aaSamw 177da6c28aaSamw static boolean_t smbadm_chkprop_priv(smbadm_prop_t *prop); 178da6c28aaSamw static int smbadm_setprop_tkowner(char *gname, smbadm_prop_t *prop); 179da6c28aaSamw static int smbadm_getprop_tkowner(char *gname, smbadm_prop_t *prop); 180da6c28aaSamw static int smbadm_setprop_backup(char *gname, smbadm_prop_t *prop); 181da6c28aaSamw static int smbadm_getprop_backup(char *gname, smbadm_prop_t *prop); 182da6c28aaSamw static int smbadm_setprop_restore(char *gname, smbadm_prop_t *prop); 183da6c28aaSamw static int smbadm_getprop_restore(char *gname, smbadm_prop_t *prop); 184da6c28aaSamw static int smbadm_setprop_desc(char *gname, smbadm_prop_t *prop); 185da6c28aaSamw static int smbadm_getprop_desc(char *gname, smbadm_prop_t *prop); 186da6c28aaSamw 187da6c28aaSamw static smbadm_prop_handle_t smbadm_ptable[] = { 188*ef4cfbfdSMatt Barden {"backup", "on | off", smbadm_setprop_backup, 189*ef4cfbfdSMatt Barden smbadm_getprop_backup, smbadm_chkprop_priv }, 190da6c28aaSamw {"restore", "on | off", smbadm_setprop_restore, 191da6c28aaSamw smbadm_getprop_restore, smbadm_chkprop_priv }, 192da6c28aaSamw {"take-ownership", "on | off", smbadm_setprop_tkowner, 193da6c28aaSamw smbadm_getprop_tkowner, smbadm_chkprop_priv }, 194da6c28aaSamw {"description", "<string>", smbadm_setprop_desc, 195da6c28aaSamw smbadm_getprop_desc, NULL }, 196da6c28aaSamw }; 197da6c28aaSamw 1983db3f65cSamw static int smbadm_init(void); 1993db3f65cSamw static void smbadm_fini(void); 200da6c28aaSamw static const char *smbadm_pwd_strerror(int error); 201da6c28aaSamw 202da6c28aaSamw /* 203da6c28aaSamw * Number of supported properties 204da6c28aaSamw */ 205da6c28aaSamw #define SMBADM_NPROP (sizeof (smbadm_ptable) / sizeof (smbadm_ptable[0])) 206da6c28aaSamw 207da6c28aaSamw static void 208da6c28aaSamw smbadm_cmdusage(FILE *fp, smbadm_cmdinfo_t *cmd) 209da6c28aaSamw { 210da6c28aaSamw switch (cmd->usage) { 211da6c28aaSamw case HELP_ADD_MEMBER: 212da6c28aaSamw (void) fprintf(fp, 213da6c28aaSamw gettext("\t%s -m member [[-m member] ...] group\n"), 214da6c28aaSamw cmd->name); 215da6c28aaSamw return; 216da6c28aaSamw 217da6c28aaSamw case HELP_CREATE: 218da6c28aaSamw (void) fprintf(fp, gettext("\t%s [-d description] group\n"), 219da6c28aaSamw cmd->name); 220da6c28aaSamw return; 221da6c28aaSamw 222da6c28aaSamw case HELP_DELETE: 223da6c28aaSamw (void) fprintf(fp, gettext("\t%s group\n"), cmd->name); 224da6c28aaSamw return; 225da6c28aaSamw 226*ef4cfbfdSMatt Barden case HELP_USER_DELETE: 2273db3f65cSamw case HELP_USER_DISABLE: 2283db3f65cSamw case HELP_USER_ENABLE: 229da6c28aaSamw (void) fprintf(fp, gettext("\t%s user\n"), cmd->name); 230da6c28aaSamw return; 231da6c28aaSamw 232da6c28aaSamw case HELP_GET: 233da6c28aaSamw (void) fprintf(fp, gettext("\t%s [[-p property] ...] group\n"), 234da6c28aaSamw cmd->name); 235da6c28aaSamw return; 236da6c28aaSamw 237da6c28aaSamw case HELP_JOIN: 2381ed6b69aSGordon Ross #if 0 /* Don't document "-p" yet, still needs work (NX 11960) */ 239b3700b07SGordon Ross (void) fprintf(fp, gettext("\t%s [-y] -p domain\n" 240b3700b07SGordon Ross "\t%s [-y] -u username domain\n\t%s [-y] -w workgroup\n"), 2411ed6b69aSGordon Ross cmd->name, cmd->name, cmd->name); 2421ed6b69aSGordon Ross #else 243b3700b07SGordon Ross (void) fprintf(fp, gettext("\t%s [-y] -u username domain\n" 244b3700b07SGordon Ross "\t%s [-y] -w workgroup\n"), cmd->name, cmd->name); 2451ed6b69aSGordon Ross #endif 246da6c28aaSamw return; 247da6c28aaSamw 248da6c28aaSamw case HELP_LIST: 249da6c28aaSamw (void) fprintf(fp, gettext("\t%s\n"), cmd->name); 25089dc44ceSjose borrego (void) fprintf(fp, 25189dc44ceSjose borrego gettext("\t\t[*] primary domain\n")); 25289dc44ceSjose borrego (void) fprintf(fp, gettext("\t\t[.] local domain\n")); 25389dc44ceSjose borrego (void) fprintf(fp, gettext("\t\t[-] other domains\n")); 25489dc44ceSjose borrego (void) fprintf(fp, 25589dc44ceSjose borrego gettext("\t\t[+] selected domain controller\n")); 256da6c28aaSamw return; 257da6c28aaSamw 25836a00406SGordon Ross case HELP_LOOKUP: 25936a00406SGordon Ross (void) fprintf(fp, 26036a00406SGordon Ross gettext("\t%s user-or-group-name\n"), 26136a00406SGordon Ross cmd->name); 26236a00406SGordon Ross return; 26336a00406SGordon Ross 264da6c28aaSamw case HELP_DEL_MEMBER: 265da6c28aaSamw (void) fprintf(fp, 266da6c28aaSamw gettext("\t%s -m member [[-m member] ...] group\n"), 267da6c28aaSamw cmd->name); 268da6c28aaSamw return; 269da6c28aaSamw 270da6c28aaSamw case HELP_RENAME: 271da6c28aaSamw (void) fprintf(fp, gettext("\t%s group new-group\n"), 272da6c28aaSamw cmd->name); 273da6c28aaSamw return; 274da6c28aaSamw 275da6c28aaSamw case HELP_SET: 276da6c28aaSamw (void) fprintf(fp, gettext("\t%s -p property=value " 277da6c28aaSamw "[[-p property=value] ...] group\n"), cmd->name); 278da6c28aaSamw return; 279da6c28aaSamw 280da6c28aaSamw case HELP_SHOW: 281da6c28aaSamw (void) fprintf(fp, gettext("\t%s [-m] [-p] [group]\n"), 282da6c28aaSamw cmd->name); 283da6c28aaSamw return; 284da6c28aaSamw 2853db3f65cSamw default: 2863db3f65cSamw break; 287da6c28aaSamw } 288da6c28aaSamw 289da6c28aaSamw abort(); 290da6c28aaSamw /* NOTREACHED */ 291da6c28aaSamw } 292da6c28aaSamw 293da6c28aaSamw static void 294da6c28aaSamw smbadm_usage(boolean_t requested) 295da6c28aaSamw { 296da6c28aaSamw FILE *fp = requested ? stdout : stderr; 297da6c28aaSamw boolean_t show_props = B_FALSE; 298da6c28aaSamw int i; 299da6c28aaSamw 300da6c28aaSamw if (curcmd == NULL) { 301da6c28aaSamw (void) fprintf(fp, 302da6c28aaSamw gettext("usage: %s [-h | <command> [options]]\n"), 303da6c28aaSamw progname); 304da6c28aaSamw (void) fprintf(fp, 305da6c28aaSamw gettext("where 'command' is one of the following:\n\n")); 306da6c28aaSamw 307da6c28aaSamw for (i = 0; i < SMBADM_NCMD; i++) 308da6c28aaSamw smbadm_cmdusage(fp, &smbadm_cmdtable[i]); 309da6c28aaSamw 310da6c28aaSamw (void) fprintf(fp, 311da6c28aaSamw gettext("\nFor property list, run %s %s|%s\n"), 312da6c28aaSamw progname, "get", "set"); 313da6c28aaSamw 314da6c28aaSamw exit(requested ? 0 : 2); 315da6c28aaSamw } 316da6c28aaSamw 317da6c28aaSamw (void) fprintf(fp, gettext("usage:\n")); 318da6c28aaSamw smbadm_cmdusage(fp, curcmd); 319da6c28aaSamw 320da6c28aaSamw if (strcmp(curcmd->name, "get") == 0 || 321da6c28aaSamw strcmp(curcmd->name, "set") == 0) 322da6c28aaSamw show_props = B_TRUE; 323da6c28aaSamw 324da6c28aaSamw if (show_props) { 325da6c28aaSamw (void) fprintf(fp, 326da6c28aaSamw gettext("\nThe following properties are supported:\n")); 327da6c28aaSamw 328da6c28aaSamw (void) fprintf(fp, "\n\t%-16s %s\n\n", 329da6c28aaSamw "PROPERTY", "VALUES"); 330da6c28aaSamw 331da6c28aaSamw for (i = 0; i < SMBADM_NPROP; i++) { 332da6c28aaSamw (void) fprintf(fp, "\t%-16s %s\n", 333da6c28aaSamw smbadm_ptable[i].p_name, 334da6c28aaSamw smbadm_ptable[i].p_dispvalue); 335da6c28aaSamw } 336da6c28aaSamw } 337da6c28aaSamw 338da6c28aaSamw exit(requested ? 0 : 2); 339da6c28aaSamw } 340da6c28aaSamw 341c8ec8eeaSjose borrego /* 342c8ec8eeaSjose borrego * smbadm_strcasecmplist 343c8ec8eeaSjose borrego * 344c8ec8eeaSjose borrego * Find a string 's' within a list of strings. 345c8ec8eeaSjose borrego * 346c8ec8eeaSjose borrego * Returns the index of the matching string or -1 if there is no match. 347c8ec8eeaSjose borrego */ 348c8ec8eeaSjose borrego static int 349c8ec8eeaSjose borrego smbadm_strcasecmplist(const char *s, ...) 350c8ec8eeaSjose borrego { 351c8ec8eeaSjose borrego va_list ap; 352c8ec8eeaSjose borrego char *p; 353c8ec8eeaSjose borrego int ndx; 354c8ec8eeaSjose borrego 355c8ec8eeaSjose borrego va_start(ap, s); 356c8ec8eeaSjose borrego 357c8ec8eeaSjose borrego for (ndx = 0; ((p = va_arg(ap, char *)) != NULL); ++ndx) { 358c8ec8eeaSjose borrego if (strcasecmp(s, p) == 0) { 359c8ec8eeaSjose borrego va_end(ap); 360c8ec8eeaSjose borrego return (ndx); 361c8ec8eeaSjose borrego } 362c8ec8eeaSjose borrego } 363c8ec8eeaSjose borrego 364c8ec8eeaSjose borrego va_end(ap); 365c8ec8eeaSjose borrego return (-1); 366c8ec8eeaSjose borrego } 367c8ec8eeaSjose borrego 368c8ec8eeaSjose borrego /* 369c8ec8eeaSjose borrego * smbadm_answer_prompt 370c8ec8eeaSjose borrego * 371c8ec8eeaSjose borrego * Prompt for the answer to a question. A default response must be 372c8ec8eeaSjose borrego * specified, which will be used if the user presses <enter> without 373c8ec8eeaSjose borrego * answering the question. 374c8ec8eeaSjose borrego */ 375c8ec8eeaSjose borrego static int 376c8ec8eeaSjose borrego smbadm_answer_prompt(const char *prompt, char *answer, const char *dflt) 377c8ec8eeaSjose borrego { 378c8ec8eeaSjose borrego char buf[SMBADM_ANSBUFSIZ]; 379c8ec8eeaSjose borrego char *p; 380c8ec8eeaSjose borrego 381c8ec8eeaSjose borrego (void) printf(gettext("%s [%s]: "), prompt, dflt); 382c8ec8eeaSjose borrego 383c8ec8eeaSjose borrego if (fgets(buf, SMBADM_ANSBUFSIZ, stdin) == NULL) 384c8ec8eeaSjose borrego return (-1); 385c8ec8eeaSjose borrego 386c8ec8eeaSjose borrego if ((p = strchr(buf, '\n')) != NULL) 387c8ec8eeaSjose borrego *p = '\0'; 388c8ec8eeaSjose borrego 389c8ec8eeaSjose borrego if (*buf == '\0') 390c8ec8eeaSjose borrego (void) strlcpy(answer, dflt, SMBADM_ANSBUFSIZ); 391c8ec8eeaSjose borrego else 392c8ec8eeaSjose borrego (void) strlcpy(answer, buf, SMBADM_ANSBUFSIZ); 393c8ec8eeaSjose borrego 394c8ec8eeaSjose borrego return (0); 395c8ec8eeaSjose borrego } 396c8ec8eeaSjose borrego 397c8ec8eeaSjose borrego /* 398c8ec8eeaSjose borrego * smbadm_confirm 399c8ec8eeaSjose borrego * 400c8ec8eeaSjose borrego * Ask a question that requires a yes/no answer. 401c8ec8eeaSjose borrego * A default response must be specified. 402c8ec8eeaSjose borrego */ 403c8ec8eeaSjose borrego static boolean_t 404c8ec8eeaSjose borrego smbadm_confirm(const char *prompt, const char *dflt) 405c8ec8eeaSjose borrego { 406c8ec8eeaSjose borrego char buf[SMBADM_ANSBUFSIZ]; 407c8ec8eeaSjose borrego 408c8ec8eeaSjose borrego for (;;) { 409c8ec8eeaSjose borrego if (smbadm_answer_prompt(prompt, buf, dflt) < 0) 410c8ec8eeaSjose borrego return (B_FALSE); 411c8ec8eeaSjose borrego 412c8ec8eeaSjose borrego if (smbadm_strcasecmplist(buf, "n", "no", 0) >= 0) 413c8ec8eeaSjose borrego return (B_FALSE); 414c8ec8eeaSjose borrego 415c8ec8eeaSjose borrego if (smbadm_strcasecmplist(buf, "y", "yes", 0) >= 0) 416c8ec8eeaSjose borrego return (B_TRUE); 417c8ec8eeaSjose borrego 418c8ec8eeaSjose borrego (void) printf(gettext("Please answer yes or no.\n")); 419c8ec8eeaSjose borrego } 420c8ec8eeaSjose borrego } 421c8ec8eeaSjose borrego 422c8ec8eeaSjose borrego static boolean_t 4238d7e4166Sjose borrego smbadm_join_prompt(const char *domain) 424c8ec8eeaSjose borrego { 4258d7e4166Sjose borrego (void) printf(gettext("After joining %s the smb service will be " 4268d7e4166Sjose borrego "restarted automatically.\n"), domain); 427c8ec8eeaSjose borrego 4288d7e4166Sjose borrego return (smbadm_confirm("Would you like to continue?", "no")); 4298d7e4166Sjose borrego } 4308d96b23eSAlan Wright 4318d7e4166Sjose borrego static void 4328d7e4166Sjose borrego smbadm_restart_service(void) 4338d7e4166Sjose borrego { 4348d7e4166Sjose borrego if (smb_smf_restart_service() != 0) { 4358d7e4166Sjose borrego (void) fprintf(stderr, 4368d7e4166Sjose borrego gettext("Unable to restart smb service. " 4378d7e4166Sjose borrego "Run 'svcs -xv smb/server' for more information.")); 438c8ec8eeaSjose borrego } 439c8ec8eeaSjose borrego } 440c8ec8eeaSjose borrego 441da6c28aaSamw /* 442da6c28aaSamw * smbadm_join 443da6c28aaSamw * 4448d7e4166Sjose borrego * Join a domain or workgroup. 4458d7e4166Sjose borrego * 4468d7e4166Sjose borrego * When joining a domain, we may receive the username, password and 4478d7e4166Sjose borrego * domain name in any of the following combinations. Note that the 4488d7e4166Sjose borrego * password is optional on the command line: if it is not provided, 4498d7e4166Sjose borrego * we will prompt for it later. 4508d7e4166Sjose borrego * 4518d7e4166Sjose borrego * username+password domain 4528d7e4166Sjose borrego * domain\username+password 4538d7e4166Sjose borrego * domain/username+password 4548d7e4166Sjose borrego * username@domain 4558d7e4166Sjose borrego * 4568d7e4166Sjose borrego * We allow domain\name+password or domain/name+password but not 4578d7e4166Sjose borrego * name+password@domain because @ is a valid password character. 4588d7e4166Sjose borrego * 4598d7e4166Sjose borrego * If the username and domain name are passed as separate command 4608d7e4166Sjose borrego * line arguments, we process them directly. Otherwise we separate 4618d7e4166Sjose borrego * them and continue as if they were separate command line arguments. 462da6c28aaSamw */ 463da6c28aaSamw static int 464da6c28aaSamw smbadm_join(int argc, char **argv) 465da6c28aaSamw { 4668d7e4166Sjose borrego char buf[MAXHOSTNAMELEN * 2]; 4678d7e4166Sjose borrego char *domain = NULL; 4688d7e4166Sjose borrego char *username = NULL; 4698d7e4166Sjose borrego uint32_t mode = 0; 470b3700b07SGordon Ross boolean_t do_prompt = B_TRUE; 471da6c28aaSamw char option; 472da6c28aaSamw 473b3700b07SGordon Ross while ((option = getopt(argc, argv, "pu:wy")) != -1) { 4741ed6b69aSGordon Ross if (mode != 0) { 4751ed6b69aSGordon Ross (void) fprintf(stderr, gettext( 4761ed6b69aSGordon Ross "join options are mutually exclusive\n")); 4771ed6b69aSGordon Ross smbadm_usage(B_FALSE); 4781ed6b69aSGordon Ross } 479da6c28aaSamw switch (option) { 4801ed6b69aSGordon Ross case 'p': 4811ed6b69aSGordon Ross mode = SMB_SECMODE_DOMAIN; 4821ed6b69aSGordon Ross /* leave username = NULL */ 483da6c28aaSamw break; 484da6c28aaSamw 485da6c28aaSamw case 'u': 4868d7e4166Sjose borrego mode = SMB_SECMODE_DOMAIN; 4878d7e4166Sjose borrego username = optarg; 4881ed6b69aSGordon Ross break; 4898d7e4166Sjose borrego 4901ed6b69aSGordon Ross case 'w': 4911ed6b69aSGordon Ross mode = SMB_SECMODE_WORKGRP; 492da6c28aaSamw break; 493da6c28aaSamw 494b3700b07SGordon Ross case 'y': 495b3700b07SGordon Ross do_prompt = B_FALSE; 496b3700b07SGordon Ross break; 497b3700b07SGordon Ross 498da6c28aaSamw default: 499da6c28aaSamw smbadm_usage(B_FALSE); 5008d7e4166Sjose borrego break; 501da6c28aaSamw } 502da6c28aaSamw } 503da6c28aaSamw 5041ed6b69aSGordon Ross if (optind < argc) 5051ed6b69aSGordon Ross domain = argv[optind]; 5061ed6b69aSGordon Ross 5071ed6b69aSGordon Ross if (username != NULL && domain == NULL) { 5081ed6b69aSGordon Ross /* 5091ed6b69aSGordon Ross * The domain was not specified as a separate 5101ed6b69aSGordon Ross * argument, check for the combination forms. 5111ed6b69aSGordon Ross */ 5121ed6b69aSGordon Ross (void) strlcpy(buf, username, sizeof (buf)); 5131ed6b69aSGordon Ross smbadm_extract_domain(buf, &username, &domain); 5141ed6b69aSGordon Ross } 5151ed6b69aSGordon Ross 5168d7e4166Sjose borrego if ((domain == NULL) || (*domain == '\0')) { 5178d7e4166Sjose borrego (void) fprintf(stderr, gettext("missing %s name\n"), 5188d7e4166Sjose borrego (mode == SMB_SECMODE_WORKGRP) ? "workgroup" : "domain"); 519da6c28aaSamw smbadm_usage(B_FALSE); 520da6c28aaSamw } 521da6c28aaSamw 5221ed6b69aSGordon Ross if (mode == SMB_SECMODE_WORKGRP) { 523b3700b07SGordon Ross return (smbadm_join_workgroup(domain, do_prompt)); 5241ed6b69aSGordon Ross } 525b3700b07SGordon Ross return (smbadm_join_domain(domain, username, do_prompt)); 5268d7e4166Sjose borrego } 527da6c28aaSamw 5288d7e4166Sjose borrego /* 5298d7e4166Sjose borrego * Workgroups comprise a collection of standalone, independently administered 5308d7e4166Sjose borrego * computers that use a common workgroup name. This is a peer-to-peer model 5318d7e4166Sjose borrego * with no formal membership mechanism. 5328d7e4166Sjose borrego */ 5338d7e4166Sjose borrego static int 534b3700b07SGordon Ross smbadm_join_workgroup(const char *workgroup, boolean_t prompt) 5358d7e4166Sjose borrego { 5368d7e4166Sjose borrego smb_joininfo_t jdi; 537b3700b07SGordon Ross smb_joinres_t jdres; 5388d7e4166Sjose borrego uint32_t status; 5398d7e4166Sjose borrego 540b3700b07SGordon Ross bzero(&jdres, sizeof (jdres)); 5418d7e4166Sjose borrego bzero(&jdi, sizeof (jdi)); 5428d7e4166Sjose borrego jdi.mode = SMB_SECMODE_WORKGRP; 5438d7e4166Sjose borrego (void) strlcpy(jdi.domain_name, workgroup, sizeof (jdi.domain_name)); 5448d7e4166Sjose borrego (void) strtrim(jdi.domain_name, " \t\n"); 5458d7e4166Sjose borrego 546fe1c642dSBill Krier if (smb_name_validate_workgroup(jdi.domain_name) != ERROR_SUCCESS) { 5478d7e4166Sjose borrego (void) fprintf(stderr, gettext("workgroup name is invalid\n")); 548da6c28aaSamw smbadm_usage(B_FALSE); 549da6c28aaSamw } 550da6c28aaSamw 551b3700b07SGordon Ross if (prompt && !smbadm_join_prompt(jdi.domain_name)) 5528d7e4166Sjose borrego return (0); 5538d7e4166Sjose borrego 554b3700b07SGordon Ross if ((status = smb_join(&jdi, &jdres)) != NT_STATUS_SUCCESS) { 5558d7e4166Sjose borrego (void) fprintf(stderr, gettext("failed to join %s: %s\n"), 5568d7e4166Sjose borrego jdi.domain_name, xlate_nt_status(status)); 5578d7e4166Sjose borrego return (1); 558da6c28aaSamw } 559da6c28aaSamw 5608d7e4166Sjose borrego (void) printf(gettext("Successfully joined %s\n"), jdi.domain_name); 5618d7e4166Sjose borrego smbadm_restart_service(); 5628d7e4166Sjose borrego return (0); 5638d7e4166Sjose borrego } 564c8ec8eeaSjose borrego 5658d7e4166Sjose borrego /* 5668d7e4166Sjose borrego * Domains comprise a centrally administered group of computers and accounts 5678d7e4166Sjose borrego * that share a common security and administration policy and database. 5688d7e4166Sjose borrego * Computers must join a domain and become domain members, which requires 5698d7e4166Sjose borrego * an administrator level account name. 5708d7e4166Sjose borrego * 5718d7e4166Sjose borrego * The '+' character is invalid within a username. We allow the password 5728d7e4166Sjose borrego * to be appended to the username using '+' as a scripting convenience. 5738d7e4166Sjose borrego */ 5748d7e4166Sjose borrego static int 575b3700b07SGordon Ross smbadm_join_domain(const char *domain, const char *username, boolean_t prompt) 5768d7e4166Sjose borrego { 5778d7e4166Sjose borrego smb_joininfo_t jdi; 578b3700b07SGordon Ross smb_joinres_t jdres; 579b3700b07SGordon Ross char *passwd_prompt; 5808d7e4166Sjose borrego char *p; 581b3700b07SGordon Ross int len, rc; 582c8ec8eeaSjose borrego 583b3700b07SGordon Ross bzero(&jdres, sizeof (jdres)); 5848d7e4166Sjose borrego bzero(&jdi, sizeof (jdi)); 5858d7e4166Sjose borrego jdi.mode = SMB_SECMODE_DOMAIN; 5868d7e4166Sjose borrego (void) strlcpy(jdi.domain_name, domain, sizeof (jdi.domain_name)); 5878d7e4166Sjose borrego (void) strtrim(jdi.domain_name, " \t\n"); 588c8ec8eeaSjose borrego 589fe1c642dSBill Krier if (smb_name_validate_domain(jdi.domain_name) != ERROR_SUCCESS) { 5908d7e4166Sjose borrego (void) fprintf(stderr, gettext("domain name is invalid\n")); 5918d7e4166Sjose borrego smbadm_usage(B_FALSE); 5928d7e4166Sjose borrego } 593c8ec8eeaSjose borrego 594b3700b07SGordon Ross if (prompt && !smbadm_join_prompt(jdi.domain_name)) 5958d7e4166Sjose borrego return (0); 596c8ec8eeaSjose borrego 5971ed6b69aSGordon Ross /* 5981ed6b69aSGordon Ross * Note: username is null for "unsecure join" 5991ed6b69aSGordon Ross * (join using a pre-created computer account) 6001ed6b69aSGordon Ross * No password either. 6011ed6b69aSGordon Ross */ 6021ed6b69aSGordon Ross if (username != NULL) { 6031ed6b69aSGordon Ross if ((p = strchr(username, '+')) != NULL) { 6041ed6b69aSGordon Ross ++p; 605da6c28aaSamw 6061ed6b69aSGordon Ross len = (int)(p - username); 6071ed6b69aSGordon Ross if (len > sizeof (jdi.domain_name)) 6081ed6b69aSGordon Ross len = sizeof (jdi.domain_name); 609da6c28aaSamw 6101ed6b69aSGordon Ross (void) strlcpy(jdi.domain_username, username, len); 6111ed6b69aSGordon Ross (void) strlcpy(jdi.domain_passwd, p, 6121ed6b69aSGordon Ross sizeof (jdi.domain_passwd)); 6131ed6b69aSGordon Ross } else { 6141ed6b69aSGordon Ross (void) strlcpy(jdi.domain_username, username, 6151ed6b69aSGordon Ross sizeof (jdi.domain_username)); 6161ed6b69aSGordon Ross } 6178d7e4166Sjose borrego 6181ed6b69aSGordon Ross if (smb_name_validate_account(jdi.domain_username) 6191ed6b69aSGordon Ross != ERROR_SUCCESS) { 6201ed6b69aSGordon Ross (void) fprintf(stderr, 6211ed6b69aSGordon Ross gettext("username contains invalid characters\n")); 622da6c28aaSamw smbadm_usage(B_FALSE); 623da6c28aaSamw } 624da6c28aaSamw 6251ed6b69aSGordon Ross if (*jdi.domain_passwd == '\0') { 626b3700b07SGordon Ross passwd_prompt = gettext("Enter domain password: "); 6271ed6b69aSGordon Ross 628b3700b07SGordon Ross if ((p = getpassphrase(passwd_prompt)) == NULL) { 6291ed6b69aSGordon Ross (void) fprintf(stderr, gettext( 6301ed6b69aSGordon Ross "missing password\n")); 6311ed6b69aSGordon Ross smbadm_usage(B_FALSE); 6321ed6b69aSGordon Ross } 6331ed6b69aSGordon Ross 6341ed6b69aSGordon Ross (void) strlcpy(jdi.domain_passwd, p, 6351ed6b69aSGordon Ross sizeof (jdi.domain_passwd)); 6361ed6b69aSGordon Ross } 637da6c28aaSamw } 638da6c28aaSamw 6398d7e4166Sjose borrego (void) printf(gettext("Joining %s ... this may take a minute ...\n"), 640da6c28aaSamw jdi.domain_name); 641da6c28aaSamw 642b3700b07SGordon Ross rc = smb_join(&jdi, &jdres); 643b3700b07SGordon Ross if (rc != 0) { 644b3700b07SGordon Ross (void) printf(gettext("Cannot call the SMB service. " 645b3700b07SGordon Ross " (error %d: %s) " 646b3700b07SGordon Ross "Please check the service status " 647b3700b07SGordon Ross "(svcs -vx network/smb/server)\n"), 648b3700b07SGordon Ross rc, strerror(rc)); 649b3700b07SGordon Ross bzero(&jdi, sizeof (jdi)); 650b3700b07SGordon Ross return (1); 651b3700b07SGordon Ross } 652da6c28aaSamw 653b3700b07SGordon Ross switch (jdres.status) { 654da6c28aaSamw case NT_STATUS_SUCCESS: 655b3700b07SGordon Ross (void) printf(gettext( 656b3700b07SGordon Ross "Successfully joined domain %s using AD server %s\n"), 657b3700b07SGordon Ross jdi.domain_name, jdres.dc_name); 6588d7e4166Sjose borrego bzero(&jdi, sizeof (jdi)); 6598d7e4166Sjose borrego smbadm_restart_service(); 660da6c28aaSamw return (0); 661da6c28aaSamw 662da6c28aaSamw case NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND: 663b3700b07SGordon Ross /* See: smb_ads_lookup_msdcs */ 664b3700b07SGordon Ross (void) fprintf(stderr, gettext( 665b3700b07SGordon Ross "failed to find any AD servers for domain: %s\n"), 666da6c28aaSamw jdi.domain_name); 667b3700b07SGordon Ross goto common; 668da6c28aaSamw 6691ed6b69aSGordon Ross case NT_STATUS_BAD_NETWORK_PATH: 670b3700b07SGordon Ross /* See: smbrdr_ctx_new / smb_ctx_resolve */ 671b3700b07SGordon Ross (void) fprintf(stderr, gettext( 672b3700b07SGordon Ross "failed to resolve address of AD server: %s\n"), 673b3700b07SGordon Ross jdres.dc_name); 674b3700b07SGordon Ross goto common; 6751ed6b69aSGordon Ross 6761ed6b69aSGordon Ross case NT_STATUS_NETWORK_ACCESS_DENIED: 677b3700b07SGordon Ross /* See: smbrdr_ctx_new / smb_ctx_get_ssn */ 678b3700b07SGordon Ross (void) fprintf(stderr, gettext( 679b3700b07SGordon Ross "failed to authenticate with AD server: %s\n"), 680b3700b07SGordon Ross jdres.dc_name); 681b3700b07SGordon Ross goto common; 682b3700b07SGordon Ross 6831ed6b69aSGordon Ross case NT_STATUS_BAD_NETWORK_NAME: 684b3700b07SGordon Ross /* 685b3700b07SGordon Ross * See: smbrdr_ctx_new / smb_ctx_get_tree 686b3700b07SGordon Ross * and: ndr_rpc_bind / smb_fh_open 687b3700b07SGordon Ross */ 688b3700b07SGordon Ross (void) fprintf(stderr, gettext( 689b3700b07SGordon Ross "failed connecting to services on AD server: %s\n"), 690b3700b07SGordon Ross jdres.dc_name); 691b3700b07SGordon Ross goto common; 6921ed6b69aSGordon Ross 693da6c28aaSamw default: 694b3700b07SGordon Ross (void) fprintf(stderr, gettext( 695b3700b07SGordon Ross "failed to join domain %s\n"), 696b3700b07SGordon Ross jdi.domain_name); 697b3700b07SGordon Ross if (jdres.dc_name[0] != '\0') { 698b3700b07SGordon Ross (void) fprintf(stderr, gettext( 699b3700b07SGordon Ross "using AD server: %s\n"), 700b3700b07SGordon Ross jdres.dc_name); 701b3700b07SGordon Ross } 702b3700b07SGordon Ross /* FALLTHROUGH */ 703b3700b07SGordon Ross common: 704b3700b07SGordon Ross if (jdres.join_err != 0) { 705b3700b07SGordon Ross (void) fprintf(stderr, "%s\n", 706b3700b07SGordon Ross smb_ads_strerror(jdres.join_err)); 707b3700b07SGordon Ross } else if (jdres.status != 0) { 708b3700b07SGordon Ross (void) fprintf(stderr, "(%s)\n", 709b3700b07SGordon Ross xlate_nt_status(jdres.status)); 710b3700b07SGordon Ross } 711b3700b07SGordon Ross (void) fprintf(stderr, gettext("Please refer to the " 712b3700b07SGordon Ross "service log for more information.\n")); 7138d7e4166Sjose borrego bzero(&jdi, sizeof (jdi)); 7148d7e4166Sjose borrego return (1); 7158d7e4166Sjose borrego } 7168d7e4166Sjose borrego } 7178d7e4166Sjose borrego 7188d7e4166Sjose borrego /* 7198d7e4166Sjose borrego * We want to process the user and domain names as separate strings. 7208d7e4166Sjose borrego * Check for names of the forms below and separate the components as 7218d7e4166Sjose borrego * required. 7228d7e4166Sjose borrego * 7238d7e4166Sjose borrego * name@domain 7248d7e4166Sjose borrego * domain\name 7258d7e4166Sjose borrego * domain/name 7268d7e4166Sjose borrego * 7278d7e4166Sjose borrego * If we encounter any of the forms above in arg, the @, / or \ 7288d7e4166Sjose borrego * separator is replaced by \0 and the username and domain pointers 7298d7e4166Sjose borrego * are changed to point to the appropriate components (in arg). 7308d7e4166Sjose borrego * 7318d7e4166Sjose borrego * If none of the separators are encountered, the username and domain 7328d7e4166Sjose borrego * pointers remain unchanged. 7338d7e4166Sjose borrego */ 7348d7e4166Sjose borrego static void 7358d7e4166Sjose borrego smbadm_extract_domain(char *arg, char **username, char **domain) 7368d7e4166Sjose borrego { 7378d7e4166Sjose borrego char *p; 7388d7e4166Sjose borrego 7398d7e4166Sjose borrego if ((p = strpbrk(arg, "/\\@")) != NULL) { 7408d7e4166Sjose borrego if (*p == '@') { 7418d7e4166Sjose borrego *p = '\0'; 7428d7e4166Sjose borrego ++p; 7438d7e4166Sjose borrego 7448d7e4166Sjose borrego if (strchr(arg, '+') != NULL) 7458d7e4166Sjose borrego return; 7468d7e4166Sjose borrego 7478d7e4166Sjose borrego *domain = p; 7488d7e4166Sjose borrego *username = arg; 7498d7e4166Sjose borrego } else { 7508d7e4166Sjose borrego *p = '\0'; 7518d7e4166Sjose borrego ++p; 7528d7e4166Sjose borrego *username = p; 7538d7e4166Sjose borrego *domain = arg; 7548d7e4166Sjose borrego } 7558d7e4166Sjose borrego } 7568d7e4166Sjose borrego } 7578d7e4166Sjose borrego 758da6c28aaSamw /* 759da6c28aaSamw * smbadm_list 760da6c28aaSamw * 761da6c28aaSamw * Displays current security mode and domain/workgroup name. 762da6c28aaSamw */ 763da6c28aaSamw /*ARGSUSED*/ 764da6c28aaSamw static int 765da6c28aaSamw smbadm_list(int argc, char **argv) 766da6c28aaSamw { 767faa1795aSjb char domain[MAXHOSTNAMELEN]; 7688d7e4166Sjose borrego char fqdn[MAXHOSTNAMELEN]; 7698d7e4166Sjose borrego char srvname[MAXHOSTNAMELEN]; 770faa1795aSjb char modename[16]; 771faa1795aSjb int rc; 7727f667e74Sjose borrego smb_inaddr_t srvipaddr; 773c8ec8eeaSjose borrego char ipstr[INET6_ADDRSTRLEN]; 774da6c28aaSamw 775faa1795aSjb rc = smb_config_getstr(SMB_CI_SECURITY, modename, sizeof (modename)); 776faa1795aSjb if (rc != SMBD_SMF_OK) { 777da6c28aaSamw (void) fprintf(stderr, 77889dc44ceSjose borrego gettext("cannot determine the operational mode\n")); 779da6c28aaSamw return (1); 780da6c28aaSamw } 781da6c28aaSamw 782faa1795aSjb if (smb_getdomainname(domain, sizeof (domain)) != 0) { 783faa1795aSjb (void) fprintf(stderr, gettext("failed to get the %s name\n"), 784faa1795aSjb modename); 785da6c28aaSamw return (1); 786da6c28aaSamw } 78789dc44ceSjose borrego 788c8ec8eeaSjose borrego if (strcmp(modename, "workgroup") == 0) { 78989dc44ceSjose borrego (void) printf(gettext("[*] [%s]\n"), domain); 790c8ec8eeaSjose borrego return (0); 791c8ec8eeaSjose borrego } 79289dc44ceSjose borrego 79389dc44ceSjose borrego (void) printf(gettext("[*] [%s]\n"), domain); 7948d7e4166Sjose borrego if ((smb_getfqdomainname(fqdn, sizeof (fqdn)) == 0) && (*fqdn != '\0')) 79589dc44ceSjose borrego (void) printf(gettext("[*] [%s]\n"), fqdn); 796c8ec8eeaSjose borrego 7978d7e4166Sjose borrego if ((smb_get_dcinfo(srvname, MAXHOSTNAMELEN, &srvipaddr) 7988d7e4166Sjose borrego == NT_STATUS_SUCCESS) && (*srvname != '\0') && 7997f667e74Sjose borrego (!smb_inet_iszero(&srvipaddr))) { 8007f667e74Sjose borrego (void) smb_inet_ntop(&srvipaddr, ipstr, 8017f667e74Sjose borrego SMB_IPSTRLEN(srvipaddr.a_family)); 802b3700b07SGordon Ross (void) printf(gettext("\t[+%s] [%s]\n"), 803b3700b07SGordon Ross srvname, ipstr); 804c8ec8eeaSjose borrego } 80589dc44ceSjose borrego 806b3700b07SGordon Ross /* Print the local and domain SID. */ 807a0aa776eSAlan Wright smb_domain_show(); 808da6c28aaSamw return (0); 809da6c28aaSamw } 810da6c28aaSamw 81136a00406SGordon Ross /* 81236a00406SGordon Ross * smbadm_lookup 81336a00406SGordon Ross * 81436a00406SGordon Ross * Lookup the SID for a given account (user or group) 81536a00406SGordon Ross */ 81636a00406SGordon Ross static int 81736a00406SGordon Ross smbadm_lookup(int argc, char **argv) 81836a00406SGordon Ross { 81936a00406SGordon Ross int i; 82036a00406SGordon Ross 82136a00406SGordon Ross if (argc < 2) { 82236a00406SGordon Ross (void) fprintf(stderr, gettext("missing account name\n")); 82336a00406SGordon Ross smbadm_usage(B_FALSE); 82436a00406SGordon Ross } 82536a00406SGordon Ross 82636a00406SGordon Ross for (i = 1; i < argc; i++) { 82736a00406SGordon Ross if (strncmp(argv[i], "S-1-", 4) == 0) 82836a00406SGordon Ross smbadm_lookup_sid(argv[i]); 82936a00406SGordon Ross else 83036a00406SGordon Ross smbadm_lookup_name(argv[i]); 83136a00406SGordon Ross } 83236a00406SGordon Ross return (0); 83336a00406SGordon Ross } 83436a00406SGordon Ross 83536a00406SGordon Ross static void 83636a00406SGordon Ross smbadm_lookup_name(char *name) 83736a00406SGordon Ross { 83836a00406SGordon Ross lsa_account_t acct; 83936a00406SGordon Ross int rc; 84036a00406SGordon Ross 84136a00406SGordon Ross if ((rc = smb_lookup_name(name, SidTypeUnknown, &acct)) != 0) { 84236a00406SGordon Ross (void) fprintf(stderr, gettext( 84336a00406SGordon Ross "\t\t%s: lookup name failed, rc=%d\n"), 84436a00406SGordon Ross name, rc); 84536a00406SGordon Ross return; 84636a00406SGordon Ross } 84736a00406SGordon Ross if (acct.a_status != NT_STATUS_SUCCESS) { 84836a00406SGordon Ross (void) fprintf(stderr, gettext("\t\t%s [%s]\n"), 84936a00406SGordon Ross name, xlate_nt_status(acct.a_status)); 85036a00406SGordon Ross return; 85136a00406SGordon Ross } 85236a00406SGordon Ross (void) printf("\t%s\n", acct.a_sid); 85336a00406SGordon Ross } 85436a00406SGordon Ross 85536a00406SGordon Ross static void 85636a00406SGordon Ross smbadm_lookup_sid(char *sidstr) 85736a00406SGordon Ross { 85836a00406SGordon Ross lsa_account_t acct; 85936a00406SGordon Ross int rc; 86036a00406SGordon Ross 86136a00406SGordon Ross if ((rc = smb_lookup_sid(sidstr, &acct)) != 0) { 86236a00406SGordon Ross (void) fprintf(stderr, gettext( 86336a00406SGordon Ross "\t\t%s: lookup SID failed, rc=%d\n"), 86436a00406SGordon Ross sidstr, rc); 86536a00406SGordon Ross return; 86636a00406SGordon Ross } 86736a00406SGordon Ross if (acct.a_status != NT_STATUS_SUCCESS) { 86836a00406SGordon Ross (void) fprintf(stderr, gettext("\t\t%s [%s]\n"), 86936a00406SGordon Ross sidstr, xlate_nt_status(acct.a_status)); 87036a00406SGordon Ross return; 87136a00406SGordon Ross } 87236a00406SGordon Ross (void) printf("\t%s\\%s\n", acct.a_domain, acct.a_name); 87336a00406SGordon Ross } 87436a00406SGordon Ross 875da6c28aaSamw /* 876da6c28aaSamw * smbadm_group_create 877da6c28aaSamw * 878da6c28aaSamw * Creates a local SMB group 879da6c28aaSamw */ 880da6c28aaSamw static int 881da6c28aaSamw smbadm_group_create(int argc, char **argv) 882da6c28aaSamw { 883da6c28aaSamw char *gname = NULL; 884da6c28aaSamw char *desc = NULL; 885da6c28aaSamw char option; 886dc20a302Sas int status; 887da6c28aaSamw 888da6c28aaSamw while ((option = getopt(argc, argv, "d:")) != -1) { 889da6c28aaSamw switch (option) { 890da6c28aaSamw case 'd': 891da6c28aaSamw desc = optarg; 892da6c28aaSamw break; 893da6c28aaSamw 894da6c28aaSamw default: 895da6c28aaSamw smbadm_usage(B_FALSE); 896da6c28aaSamw } 897da6c28aaSamw } 898da6c28aaSamw 899da6c28aaSamw gname = argv[optind]; 900da6c28aaSamw if (optind >= argc || gname == NULL || *gname == '\0') { 901da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 902da6c28aaSamw smbadm_usage(B_FALSE); 903da6c28aaSamw } 904da6c28aaSamw 905dc20a302Sas status = smb_lgrp_add(gname, desc); 906dc20a302Sas if (status != SMB_LGRP_SUCCESS) { 907da6c28aaSamw (void) fprintf(stderr, 90896a62adaSjoyce mcintosh gettext("failed to create %s (%s)\n"), gname, 909dc20a302Sas smb_lgrp_strerror(status)); 910da6c28aaSamw } else { 91196a62adaSjoyce mcintosh (void) printf(gettext("%s created\n"), gname); 912da6c28aaSamw } 913da6c28aaSamw 914da6c28aaSamw return (status); 915da6c28aaSamw } 916da6c28aaSamw 917da6c28aaSamw /* 918da6c28aaSamw * smbadm_group_dump_members 919da6c28aaSamw * 920da6c28aaSamw * Dump group members details. 921da6c28aaSamw */ 922da6c28aaSamw static void 923dc20a302Sas smbadm_group_dump_members(smb_gsid_t *members, int num) 924da6c28aaSamw { 925fe1c642dSBill Krier char sidstr[SMB_SID_STRSZ]; 926fe1c642dSBill Krier lsa_account_t acct; 927fe1c642dSBill Krier int i; 928da6c28aaSamw 929dc20a302Sas if (num == 0) { 930da6c28aaSamw (void) printf(gettext("\tNo members\n")); 931da6c28aaSamw return; 932da6c28aaSamw } 933da6c28aaSamw 934da6c28aaSamw (void) printf(gettext("\tMembers:\n")); 935dc20a302Sas for (i = 0; i < num; i++) { 936fe1c642dSBill Krier smb_sid_tostr(members[i].gs_sid, sidstr); 937fe1c642dSBill Krier 938fe1c642dSBill Krier if (smb_lookup_sid(sidstr, &acct) == 0) { 939fe1c642dSBill Krier if (acct.a_status == NT_STATUS_SUCCESS) 940fe1c642dSBill Krier smbadm_group_show_name(acct.a_domain, 941fe1c642dSBill Krier acct.a_name); 942fe1c642dSBill Krier else 943fe1c642dSBill Krier (void) printf(gettext("\t\t%s [%s]\n"), 944fe1c642dSBill Krier sidstr, xlate_nt_status(acct.a_status)); 945fe1c642dSBill Krier } else { 9468c10a865Sas (void) printf(gettext("\t\t%s\n"), sidstr); 947fe1c642dSBill Krier } 948da6c28aaSamw } 949da6c28aaSamw } 950da6c28aaSamw 951fe1c642dSBill Krier static void 952fe1c642dSBill Krier smbadm_group_show_name(const char *domain, const char *name) 953fe1c642dSBill Krier { 954fe1c642dSBill Krier if (strchr(domain, '.') != NULL) 95536a00406SGordon Ross (void) printf("\t\t%s@%s\n", name, domain); 956fe1c642dSBill Krier else 95736a00406SGordon Ross (void) printf("\t\t%s\\%s\n", domain, name); 958fe1c642dSBill Krier } 959fe1c642dSBill Krier 960da6c28aaSamw /* 961da6c28aaSamw * smbadm_group_dump_privs 962da6c28aaSamw * 963da6c28aaSamw * Dump group privilege details. 964da6c28aaSamw */ 965da6c28aaSamw static void 966dc20a302Sas smbadm_group_dump_privs(smb_privset_t *privs) 967da6c28aaSamw { 968dc20a302Sas smb_privinfo_t *pinfo; 969dc20a302Sas char *pstatus; 970da6c28aaSamw int i; 971da6c28aaSamw 972da6c28aaSamw (void) printf(gettext("\tPrivileges: \n")); 973da6c28aaSamw 974dc20a302Sas for (i = 0; i < privs->priv_cnt; i++) { 975dc20a302Sas pinfo = smb_priv_getbyvalue(privs->priv[i].luid.lo_part); 976dc20a302Sas if ((pinfo == NULL) || (pinfo->flags & PF_PRESENTABLE) == 0) 977da6c28aaSamw continue; 978da6c28aaSamw 979dc20a302Sas switch (privs->priv[i].attrs) { 980dc20a302Sas case SE_PRIVILEGE_ENABLED: 981dc20a302Sas pstatus = "On"; 982dc20a302Sas break; 983dc20a302Sas case SE_PRIVILEGE_DISABLED: 984dc20a302Sas pstatus = "Off"; 985dc20a302Sas break; 986dc20a302Sas default: 987dc20a302Sas pstatus = "Unknown"; 988dc20a302Sas break; 989da6c28aaSamw } 990dc20a302Sas (void) printf(gettext("\t\t%s: %s\n"), pinfo->name, pstatus); 991da6c28aaSamw } 992da6c28aaSamw 993dc20a302Sas if (privs->priv_cnt == 0) 994da6c28aaSamw (void) printf(gettext("\t\tNo privileges\n")); 995da6c28aaSamw } 996da6c28aaSamw 997da6c28aaSamw /* 998da6c28aaSamw * smbadm_group_dump 999da6c28aaSamw * 1000da6c28aaSamw * Dump group details. 1001da6c28aaSamw */ 1002dc20a302Sas static void 1003dc20a302Sas smbadm_group_dump(smb_group_t *grp, boolean_t show_mem, boolean_t show_privs) 1004da6c28aaSamw { 10056537f381Sas char sidstr[SMB_SID_STRSZ]; 1006da6c28aaSamw 1007dc20a302Sas (void) printf(gettext("%s (%s)\n"), grp->sg_name, grp->sg_cmnt); 1008da6c28aaSamw 10096537f381Sas smb_sid_tostr(grp->sg_id.gs_sid, sidstr); 1010dc20a302Sas (void) printf(gettext("\tSID: %s\n"), sidstr); 1011da6c28aaSamw 1012dc20a302Sas if (show_privs) 1013dc20a302Sas smbadm_group_dump_privs(grp->sg_privs); 1014da6c28aaSamw 1015dc20a302Sas if (show_mem) 1016dc20a302Sas smbadm_group_dump_members(grp->sg_members, grp->sg_nmembers); 1017da6c28aaSamw } 1018da6c28aaSamw 1019da6c28aaSamw /* 1020da6c28aaSamw * smbadm_group_show 1021da6c28aaSamw * 1022da6c28aaSamw */ 1023da6c28aaSamw static int 1024da6c28aaSamw smbadm_group_show(int argc, char **argv) 1025da6c28aaSamw { 1026da6c28aaSamw char *gname = NULL; 1027da6c28aaSamw boolean_t show_privs; 1028da6c28aaSamw boolean_t show_members; 1029da6c28aaSamw char option; 1030dc20a302Sas int status; 1031dc20a302Sas smb_group_t grp; 1032dc20a302Sas smb_giter_t gi; 1033da6c28aaSamw 1034da6c28aaSamw show_privs = show_members = B_FALSE; 1035da6c28aaSamw 1036da6c28aaSamw while ((option = getopt(argc, argv, "mp")) != -1) { 1037da6c28aaSamw switch (option) { 1038da6c28aaSamw case 'm': 1039da6c28aaSamw show_members = B_TRUE; 1040da6c28aaSamw break; 1041da6c28aaSamw case 'p': 1042da6c28aaSamw show_privs = B_TRUE; 1043da6c28aaSamw break; 1044da6c28aaSamw 1045da6c28aaSamw default: 1046da6c28aaSamw smbadm_usage(B_FALSE); 1047da6c28aaSamw } 1048da6c28aaSamw } 1049da6c28aaSamw 1050da6c28aaSamw gname = argv[optind]; 1051da6c28aaSamw if (optind >= argc || gname == NULL || *gname == '\0') 1052da6c28aaSamw gname = "*"; 1053da6c28aaSamw 1054dc20a302Sas if (strcmp(gname, "*")) { 1055dc20a302Sas status = smb_lgrp_getbyname(gname, &grp); 1056dc20a302Sas if (status == SMB_LGRP_SUCCESS) { 1057dc20a302Sas smbadm_group_dump(&grp, show_members, show_privs); 1058dc20a302Sas smb_lgrp_free(&grp); 1059dc20a302Sas } else { 1060da6c28aaSamw (void) fprintf(stderr, 10618d7e4166Sjose borrego gettext("failed to find %s (%s)\n"), 1062dc20a302Sas gname, smb_lgrp_strerror(status)); 1063da6c28aaSamw } 1064dc20a302Sas return (status); 1065dc20a302Sas } 1066da6c28aaSamw 10676537f381Sas if ((status = smb_lgrp_iteropen(&gi)) != SMB_LGRP_SUCCESS) { 10688d7e4166Sjose borrego (void) fprintf(stderr, gettext("failed to list groups (%s)\n"), 1069dc20a302Sas smb_lgrp_strerror(status)); 1070dc20a302Sas return (status); 1071dc20a302Sas } 1072da6c28aaSamw 10736537f381Sas while ((status = smb_lgrp_iterate(&gi, &grp)) == SMB_LGRP_SUCCESS) { 1074dc20a302Sas smbadm_group_dump(&grp, show_members, show_privs); 1075dc20a302Sas smb_lgrp_free(&grp); 1076da6c28aaSamw } 10776537f381Sas 1078dc20a302Sas smb_lgrp_iterclose(&gi); 1079da6c28aaSamw 10809fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if ((status != SMB_LGRP_NO_MORE) || smb_lgrp_itererror(&gi)) { 10819fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (status != SMB_LGRP_NO_MORE) 1082b819cea2SGordon Ross smb_syslog(LOG_ERR, "smb_lgrp_iterate: %s", 10839fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_lgrp_strerror(status)); 10849fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States 10856537f381Sas (void) fprintf(stderr, 10869fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States gettext("\nAn error occurred while retrieving group data.\n" 10879fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States "Check the system log for more information.\n")); 10886537f381Sas return (status); 10896537f381Sas } 10906537f381Sas 1091dc20a302Sas return (0); 1092da6c28aaSamw } 1093da6c28aaSamw 1094da6c28aaSamw /* 1095da6c28aaSamw * smbadm_group_delete 1096da6c28aaSamw */ 1097da6c28aaSamw static int 1098da6c28aaSamw smbadm_group_delete(int argc, char **argv) 1099da6c28aaSamw { 1100da6c28aaSamw char *gname = NULL; 1101dc20a302Sas int status; 1102da6c28aaSamw 1103da6c28aaSamw gname = argv[optind]; 1104da6c28aaSamw if (optind >= argc || gname == NULL || *gname == '\0') { 1105da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 1106da6c28aaSamw smbadm_usage(B_FALSE); 1107da6c28aaSamw } 1108da6c28aaSamw 1109dc20a302Sas status = smb_lgrp_delete(gname); 1110dc20a302Sas if (status != SMB_LGRP_SUCCESS) { 1111da6c28aaSamw (void) fprintf(stderr, 11128d7e4166Sjose borrego gettext("failed to delete %s (%s)\n"), gname, 1113dc20a302Sas smb_lgrp_strerror(status)); 1114da6c28aaSamw } else { 111596a62adaSjoyce mcintosh (void) printf(gettext("%s deleted\n"), gname); 1116da6c28aaSamw } 1117da6c28aaSamw 1118da6c28aaSamw return (status); 1119da6c28aaSamw } 1120da6c28aaSamw 1121da6c28aaSamw /* 1122da6c28aaSamw * smbadm_group_rename 1123da6c28aaSamw */ 1124da6c28aaSamw static int 1125da6c28aaSamw smbadm_group_rename(int argc, char **argv) 1126da6c28aaSamw { 1127da6c28aaSamw char *gname = NULL; 1128da6c28aaSamw char *ngname = NULL; 1129dc20a302Sas int status; 1130da6c28aaSamw 1131da6c28aaSamw gname = argv[optind]; 1132da6c28aaSamw if (optind++ >= argc || gname == NULL || *gname == '\0') { 1133da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 1134da6c28aaSamw smbadm_usage(B_FALSE); 1135da6c28aaSamw } 1136da6c28aaSamw 1137da6c28aaSamw ngname = argv[optind]; 1138da6c28aaSamw if (optind >= argc || ngname == NULL || *ngname == '\0') { 1139da6c28aaSamw (void) fprintf(stderr, gettext("missing new group name\n")); 1140da6c28aaSamw smbadm_usage(B_FALSE); 1141da6c28aaSamw } 1142da6c28aaSamw 1143dc20a302Sas status = smb_lgrp_rename(gname, ngname); 1144dc20a302Sas if (status != SMB_LGRP_SUCCESS) { 1145dc20a302Sas if (status == SMB_LGRP_EXISTS) 1146dc20a302Sas (void) fprintf(stderr, 1147dc20a302Sas gettext("failed to rename '%s' (%s already " 1148dc20a302Sas "exists)\n"), gname, ngname); 1149dc20a302Sas else 1150dc20a302Sas (void) fprintf(stderr, 1151dc20a302Sas gettext("failed to rename '%s' (%s)\n"), gname, 1152dc20a302Sas smb_lgrp_strerror(status)); 1153da6c28aaSamw } else { 1154dc20a302Sas (void) printf(gettext("'%s' renamed to '%s'\n"), gname, ngname); 1155da6c28aaSamw } 1156da6c28aaSamw 1157da6c28aaSamw return (status); 1158da6c28aaSamw } 1159da6c28aaSamw 1160da6c28aaSamw /* 1161da6c28aaSamw * smbadm_group_setprop 1162da6c28aaSamw * 1163da6c28aaSamw * Set the group properties. 1164da6c28aaSamw */ 1165da6c28aaSamw static int 1166da6c28aaSamw smbadm_group_setprop(int argc, char **argv) 1167da6c28aaSamw { 1168da6c28aaSamw char *gname = NULL; 1169da6c28aaSamw smbadm_prop_t props[SMBADM_NPROP]; 1170da6c28aaSamw smbadm_prop_handle_t *phandle; 1171da6c28aaSamw char option; 1172da6c28aaSamw int pcnt = 0; 1173da6c28aaSamw int ret; 1174da6c28aaSamw int p; 1175da6c28aaSamw 1176da6c28aaSamw bzero(props, SMBADM_NPROP * sizeof (smbadm_prop_t)); 1177da6c28aaSamw 1178da6c28aaSamw while ((option = getopt(argc, argv, "p:")) != -1) { 1179da6c28aaSamw switch (option) { 1180da6c28aaSamw case 'p': 1181da6c28aaSamw if (pcnt >= SMBADM_NPROP) { 1182da6c28aaSamw (void) fprintf(stderr, 1183da6c28aaSamw gettext("exceeded number of supported" 1184da6c28aaSamw " properties\n")); 1185da6c28aaSamw smbadm_usage(B_FALSE); 1186da6c28aaSamw } 1187da6c28aaSamw 1188dc20a302Sas if (smbadm_prop_parse(optarg, &props[pcnt++]) != 0) 1189dc20a302Sas smbadm_usage(B_FALSE); 1190da6c28aaSamw break; 1191da6c28aaSamw 1192da6c28aaSamw default: 1193da6c28aaSamw smbadm_usage(B_FALSE); 1194da6c28aaSamw } 1195da6c28aaSamw } 1196da6c28aaSamw 1197da6c28aaSamw if (pcnt == 0) { 1198da6c28aaSamw (void) fprintf(stderr, 1199da6c28aaSamw gettext("missing property=value argument\n")); 1200da6c28aaSamw smbadm_usage(B_FALSE); 1201da6c28aaSamw } 1202da6c28aaSamw 1203da6c28aaSamw gname = argv[optind]; 1204da6c28aaSamw if (optind >= argc || gname == NULL || *gname == '\0') { 1205da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 1206da6c28aaSamw smbadm_usage(B_FALSE); 1207da6c28aaSamw } 1208da6c28aaSamw 1209da6c28aaSamw for (p = 0; p < pcnt; p++) { 1210da6c28aaSamw phandle = smbadm_prop_gethandle(props[p].p_name); 1211da6c28aaSamw if (phandle) { 1212da6c28aaSamw if (phandle->p_setfn(gname, &props[p]) != 0) 1213da6c28aaSamw ret = 1; 1214da6c28aaSamw } 1215da6c28aaSamw } 1216da6c28aaSamw 1217da6c28aaSamw return (ret); 1218da6c28aaSamw } 1219da6c28aaSamw 1220da6c28aaSamw /* 1221da6c28aaSamw * smbadm_group_getprop 1222da6c28aaSamw * 1223da6c28aaSamw * Get the group properties. 1224da6c28aaSamw */ 1225da6c28aaSamw static int 1226da6c28aaSamw smbadm_group_getprop(int argc, char **argv) 1227da6c28aaSamw { 1228da6c28aaSamw char *gname = NULL; 1229da6c28aaSamw smbadm_prop_t props[SMBADM_NPROP]; 1230da6c28aaSamw smbadm_prop_handle_t *phandle; 1231da6c28aaSamw char option; 1232da6c28aaSamw int pcnt = 0; 1233da6c28aaSamw int ret; 1234da6c28aaSamw int p; 1235da6c28aaSamw 1236da6c28aaSamw bzero(props, SMBADM_NPROP * sizeof (smbadm_prop_t)); 1237da6c28aaSamw 1238da6c28aaSamw while ((option = getopt(argc, argv, "p:")) != -1) { 1239da6c28aaSamw switch (option) { 1240da6c28aaSamw case 'p': 1241da6c28aaSamw if (pcnt >= SMBADM_NPROP) { 1242da6c28aaSamw (void) fprintf(stderr, 1243da6c28aaSamw gettext("exceeded number of supported" 1244da6c28aaSamw " properties\n")); 1245da6c28aaSamw smbadm_usage(B_FALSE); 1246da6c28aaSamw } 1247da6c28aaSamw 1248dc20a302Sas if (smbadm_prop_parse(optarg, &props[pcnt++]) != 0) 1249dc20a302Sas smbadm_usage(B_FALSE); 1250da6c28aaSamw break; 1251da6c28aaSamw 1252da6c28aaSamw default: 1253da6c28aaSamw smbadm_usage(B_FALSE); 1254da6c28aaSamw } 1255da6c28aaSamw } 1256da6c28aaSamw 1257da6c28aaSamw gname = argv[optind]; 1258da6c28aaSamw if (optind >= argc || gname == NULL || *gname == '\0') { 1259da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 1260da6c28aaSamw smbadm_usage(B_FALSE); 1261da6c28aaSamw } 1262da6c28aaSamw 1263da6c28aaSamw if (pcnt == 0) { 1264da6c28aaSamw /* 1265da6c28aaSamw * If no property has be specified then get 1266da6c28aaSamw * all the properties. 1267da6c28aaSamw */ 1268da6c28aaSamw pcnt = SMBADM_NPROP; 1269da6c28aaSamw for (p = 0; p < pcnt; p++) 1270da6c28aaSamw props[p].p_name = smbadm_ptable[p].p_name; 1271da6c28aaSamw } 1272da6c28aaSamw 1273da6c28aaSamw for (p = 0; p < pcnt; p++) { 1274da6c28aaSamw phandle = smbadm_prop_gethandle(props[p].p_name); 1275da6c28aaSamw if (phandle) { 1276da6c28aaSamw if (phandle->p_getfn(gname, &props[p]) != 0) 1277da6c28aaSamw ret = 1; 1278da6c28aaSamw } 1279da6c28aaSamw } 1280da6c28aaSamw 1281da6c28aaSamw return (ret); 1282da6c28aaSamw } 1283da6c28aaSamw 1284da6c28aaSamw /* 1285da6c28aaSamw * smbadm_group_addmember 1286da6c28aaSamw * 1287da6c28aaSamw */ 1288da6c28aaSamw static int 1289da6c28aaSamw smbadm_group_addmember(int argc, char **argv) 1290da6c28aaSamw { 1291da6c28aaSamw char *gname = NULL; 1292da6c28aaSamw char **mname; 1293da6c28aaSamw char option; 1294da6c28aaSamw int mcnt = 0; 1295da6c28aaSamw int ret = 0; 1296da6c28aaSamw int i; 1297da6c28aaSamw 1298da6c28aaSamw 1299da6c28aaSamw mname = (char **)malloc(argc * sizeof (char *)); 1300da6c28aaSamw if (mname == NULL) { 13018d7e4166Sjose borrego warn(gettext("failed to add group member")); 1302da6c28aaSamw return (1); 1303da6c28aaSamw } 1304da6c28aaSamw bzero(mname, argc * sizeof (char *)); 1305da6c28aaSamw 1306da6c28aaSamw while ((option = getopt(argc, argv, "m:")) != -1) { 1307da6c28aaSamw switch (option) { 1308da6c28aaSamw case 'm': 1309da6c28aaSamw mname[mcnt++] = optarg; 1310da6c28aaSamw break; 1311da6c28aaSamw 1312da6c28aaSamw default: 1313da6c28aaSamw free(mname); 1314da6c28aaSamw smbadm_usage(B_FALSE); 1315da6c28aaSamw } 1316da6c28aaSamw } 1317da6c28aaSamw 1318da6c28aaSamw if (mcnt == 0) { 1319da6c28aaSamw (void) fprintf(stderr, gettext("missing member name\n")); 1320da6c28aaSamw free(mname); 1321da6c28aaSamw smbadm_usage(B_FALSE); 1322da6c28aaSamw } 1323da6c28aaSamw 1324da6c28aaSamw gname = argv[optind]; 1325da6c28aaSamw if (optind >= argc || gname == NULL || *gname == 0) { 1326da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 1327da6c28aaSamw free(mname); 1328da6c28aaSamw smbadm_usage(B_FALSE); 1329da6c28aaSamw } 1330da6c28aaSamw 1331da6c28aaSamw for (i = 0; i < mcnt; i++) { 1332da6c28aaSamw if (mname[i] == NULL) 1333da6c28aaSamw continue; 133436a00406SGordon Ross ret |= smbadm_group_add_del_member( 133536a00406SGordon Ross gname, mname[i], SMBADM_GRP_ADDMEMBER); 1336da6c28aaSamw } 1337da6c28aaSamw 1338da6c28aaSamw free(mname); 1339da6c28aaSamw return (ret); 1340da6c28aaSamw } 1341da6c28aaSamw 1342da6c28aaSamw /* 1343da6c28aaSamw * smbadm_group_delmember 1344da6c28aaSamw */ 1345da6c28aaSamw static int 1346da6c28aaSamw smbadm_group_delmember(int argc, char **argv) 1347da6c28aaSamw { 1348da6c28aaSamw char *gname = NULL; 1349da6c28aaSamw char **mname; 1350da6c28aaSamw char option; 1351da6c28aaSamw int mcnt = 0; 1352da6c28aaSamw int ret = 0; 1353da6c28aaSamw int i; 1354da6c28aaSamw 1355da6c28aaSamw mname = (char **)malloc(argc * sizeof (char *)); 1356da6c28aaSamw if (mname == NULL) { 13578d7e4166Sjose borrego warn(gettext("failed to delete group member")); 1358da6c28aaSamw return (1); 1359da6c28aaSamw } 1360da6c28aaSamw bzero(mname, argc * sizeof (char *)); 1361da6c28aaSamw 1362da6c28aaSamw while ((option = getopt(argc, argv, "m:")) != -1) { 1363da6c28aaSamw switch (option) { 1364da6c28aaSamw case 'm': 1365da6c28aaSamw mname[mcnt++] = optarg; 1366da6c28aaSamw break; 1367da6c28aaSamw 1368da6c28aaSamw default: 1369da6c28aaSamw free(mname); 1370da6c28aaSamw smbadm_usage(B_FALSE); 1371da6c28aaSamw } 1372da6c28aaSamw } 1373da6c28aaSamw 1374da6c28aaSamw if (mcnt == 0) { 1375da6c28aaSamw (void) fprintf(stderr, gettext("missing member name\n")); 1376da6c28aaSamw free(mname); 1377da6c28aaSamw smbadm_usage(B_FALSE); 1378da6c28aaSamw } 1379da6c28aaSamw 1380da6c28aaSamw gname = argv[optind]; 1381da6c28aaSamw if (optind >= argc || gname == NULL || *gname == 0) { 1382da6c28aaSamw (void) fprintf(stderr, gettext("missing group name\n")); 1383da6c28aaSamw free(mname); 1384da6c28aaSamw smbadm_usage(B_FALSE); 1385da6c28aaSamw } 1386da6c28aaSamw 1387da6c28aaSamw 1388da6c28aaSamw for (i = 0; i < mcnt; i++) { 1389fe1c642dSBill Krier ret = 0; 1390da6c28aaSamw if (mname[i] == NULL) 1391da6c28aaSamw continue; 139236a00406SGordon Ross ret |= smbadm_group_add_del_member( 139336a00406SGordon Ross gname, mname[i], SMBADM_GRP_DELMEMBER); 139436a00406SGordon Ross } 1395da6c28aaSamw 139636a00406SGordon Ross free(mname); 139736a00406SGordon Ross return (ret); 139836a00406SGordon Ross } 1399dc20a302Sas 140036a00406SGordon Ross static int 140136a00406SGordon Ross smbadm_group_add_del_member(char *gname, char *mname, 1402*ef4cfbfdSMatt Barden smbadm_grp_action_t act) 140336a00406SGordon Ross { 140436a00406SGordon Ross lsa_account_t acct; 140536a00406SGordon Ross smb_gsid_t msid; 140636a00406SGordon Ross char *sidstr; 140736a00406SGordon Ross char *act_str; 140836a00406SGordon Ross int rc; 1409fe1c642dSBill Krier 141036a00406SGordon Ross if (strncmp(mname, "S-1-", 4) == 0) { 141136a00406SGordon Ross /* 141236a00406SGordon Ross * We are given a SID. Just use it. 141336a00406SGordon Ross * 1414d4c7367eSGordon Ross * We'd like the real account type if we can get it, 141536a00406SGordon Ross * but don't want to error out if we can't get it. 1416d4c7367eSGordon Ross * Lacking other info, assume it's a group. 141736a00406SGordon Ross */ 141836a00406SGordon Ross sidstr = mname; 141936a00406SGordon Ross rc = smb_lookup_sid(sidstr, &acct); 142036a00406SGordon Ross if ((rc != 0) || (acct.a_status != NT_STATUS_SUCCESS)) 1421d4c7367eSGordon Ross acct.a_sidtype = SidTypeGroup; 142236a00406SGordon Ross } else { 142336a00406SGordon Ross rc = smb_lookup_name(mname, SidTypeUnknown, &acct); 142436a00406SGordon Ross if ((rc != 0) || (acct.a_status != NT_STATUS_SUCCESS)) { 1425fe1c642dSBill Krier (void) fprintf(stderr, 142636a00406SGordon Ross gettext("%s: name lookup failed\n"), mname); 142736a00406SGordon Ross return (1); 1428fe1c642dSBill Krier } 142936a00406SGordon Ross sidstr = acct.a_sid; 143036a00406SGordon Ross } 1431fe1c642dSBill Krier 143236a00406SGordon Ross msid.gs_type = acct.a_sidtype; 143336a00406SGordon Ross if ((msid.gs_sid = smb_sid_fromstr(sidstr)) == NULL) { 143436a00406SGordon Ross (void) fprintf(stderr, 143536a00406SGordon Ross gettext("%s: no memory for SID\n"), sidstr); 143636a00406SGordon Ross return (1); 1437da6c28aaSamw } 1438da6c28aaSamw 143936a00406SGordon Ross switch (act) { 144036a00406SGordon Ross case SMBADM_GRP_ADDMEMBER: 144136a00406SGordon Ross act_str = gettext("add"); 144236a00406SGordon Ross rc = smb_lgrp_add_member(gname, 144336a00406SGordon Ross msid.gs_sid, msid.gs_type); 144436a00406SGordon Ross break; 144536a00406SGordon Ross case SMBADM_GRP_DELMEMBER: 144636a00406SGordon Ross act_str = gettext("remove"); 144736a00406SGordon Ross rc = smb_lgrp_del_member(gname, 144836a00406SGordon Ross msid.gs_sid, msid.gs_type); 144936a00406SGordon Ross break; 145036a00406SGordon Ross default: 145136a00406SGordon Ross rc = SMB_LGRP_INTERNAL_ERROR; 145236a00406SGordon Ross break; 145336a00406SGordon Ross } 145436a00406SGordon Ross 145536a00406SGordon Ross smb_sid_free(msid.gs_sid); 145636a00406SGordon Ross 145736a00406SGordon Ross if (rc != SMB_LGRP_SUCCESS) { 145836a00406SGordon Ross (void) fprintf(stderr, 145936a00406SGordon Ross gettext("failed to %s %s (%s)\n"), 146036a00406SGordon Ross act_str, mname, smb_lgrp_strerror(rc)); 146136a00406SGordon Ross return (1); 146236a00406SGordon Ross } 146336a00406SGordon Ross return (0); 1464da6c28aaSamw } 1465da6c28aaSamw 1466*ef4cfbfdSMatt Barden static int 1467*ef4cfbfdSMatt Barden smbadm_user_delete(int argc, char **argv) 1468*ef4cfbfdSMatt Barden { 1469*ef4cfbfdSMatt Barden int error; 1470*ef4cfbfdSMatt Barden char *user = NULL; 1471*ef4cfbfdSMatt Barden 1472*ef4cfbfdSMatt Barden user = argv[optind]; 1473*ef4cfbfdSMatt Barden if (optind >= argc || user == NULL || *user == '\0') { 1474*ef4cfbfdSMatt Barden (void) fprintf(stderr, gettext("missing user name\n")); 1475*ef4cfbfdSMatt Barden smbadm_usage(B_FALSE); 1476*ef4cfbfdSMatt Barden } 1477*ef4cfbfdSMatt Barden 1478*ef4cfbfdSMatt Barden error = smb_pwd_setcntl(user, SMB_PWC_DELETE); 1479*ef4cfbfdSMatt Barden if (error == SMB_PWE_SUCCESS) 1480*ef4cfbfdSMatt Barden (void) printf(gettext("%s has been deleted.\n"), user); 1481*ef4cfbfdSMatt Barden else 1482*ef4cfbfdSMatt Barden (void) fprintf(stderr, "%s\n", smbadm_pwd_strerror(error)); 1483*ef4cfbfdSMatt Barden 1484*ef4cfbfdSMatt Barden return (error); 1485*ef4cfbfdSMatt Barden } 1486*ef4cfbfdSMatt Barden 1487da6c28aaSamw static int 1488da6c28aaSamw smbadm_user_disable(int argc, char **argv) 1489da6c28aaSamw { 1490da6c28aaSamw int error; 1491da6c28aaSamw char *user = NULL; 1492da6c28aaSamw 1493da6c28aaSamw user = argv[optind]; 1494da6c28aaSamw if (optind >= argc || user == NULL || *user == '\0') { 1495da6c28aaSamw (void) fprintf(stderr, gettext("missing user name\n")); 1496da6c28aaSamw smbadm_usage(B_FALSE); 1497da6c28aaSamw } 1498da6c28aaSamw 1499da6c28aaSamw error = smb_pwd_setcntl(user, SMB_PWC_DISABLE); 1500da6c28aaSamw if (error == SMB_PWE_SUCCESS) 1501da6c28aaSamw (void) printf(gettext("%s is disabled.\n"), user); 1502da6c28aaSamw else 1503da6c28aaSamw (void) fprintf(stderr, "%s\n", smbadm_pwd_strerror(error)); 1504da6c28aaSamw 1505da6c28aaSamw return (error); 1506da6c28aaSamw } 1507da6c28aaSamw 1508da6c28aaSamw static int 1509da6c28aaSamw smbadm_user_enable(int argc, char **argv) 1510da6c28aaSamw { 1511da6c28aaSamw int error; 1512da6c28aaSamw char *user = NULL; 1513da6c28aaSamw 1514da6c28aaSamw user = argv[optind]; 1515da6c28aaSamw if (optind >= argc || user == NULL || *user == '\0') { 1516da6c28aaSamw (void) fprintf(stderr, gettext("missing user name\n")); 1517da6c28aaSamw smbadm_usage(B_FALSE); 1518da6c28aaSamw } 1519da6c28aaSamw 1520da6c28aaSamw error = smb_pwd_setcntl(user, SMB_PWC_ENABLE); 1521da6c28aaSamw if (error == SMB_PWE_SUCCESS) 1522da6c28aaSamw (void) printf(gettext("%s is enabled.\n"), user); 1523da6c28aaSamw else 1524da6c28aaSamw (void) fprintf(stderr, "%s\n", smbadm_pwd_strerror(error)); 1525da6c28aaSamw 1526da6c28aaSamw return (error); 1527da6c28aaSamw } 1528da6c28aaSamw 1529da6c28aaSamw 1530da6c28aaSamw int 1531da6c28aaSamw main(int argc, char **argv) 1532da6c28aaSamw { 1533dc20a302Sas int ret; 1534da6c28aaSamw int i; 1535da6c28aaSamw 153696a62adaSjoyce mcintosh (void) setlocale(LC_ALL, ""); 153796a62adaSjoyce mcintosh (void) textdomain(TEXT_DOMAIN); 153896a62adaSjoyce mcintosh 1539da6c28aaSamw (void) malloc(0); /* satisfy libumem dependency */ 1540da6c28aaSamw 1541da6c28aaSamw progname = basename(argv[0]); 1542da6c28aaSamw 1543da6c28aaSamw if (is_system_labeled()) { 1544da6c28aaSamw (void) fprintf(stderr, 1545da6c28aaSamw gettext("Trusted Extensions not supported\n")); 15468622ec45SGordon Ross return (1); 1547da6c28aaSamw } 1548da6c28aaSamw 1549da6c28aaSamw if (argc < 2) { 1550da6c28aaSamw (void) fprintf(stderr, gettext("missing command\n")); 1551da6c28aaSamw smbadm_usage(B_FALSE); 1552da6c28aaSamw } 1553da6c28aaSamw 1554da6c28aaSamw /* 1555da6c28aaSamw * Special case "cmd --help/-?" 1556da6c28aaSamw */ 1557da6c28aaSamw if (strcmp(argv[1], "-?") == 0 || 1558da6c28aaSamw strcmp(argv[1], "--help") == 0 || 1559da6c28aaSamw strcmp(argv[1], "-h") == 0) 1560da6c28aaSamw smbadm_usage(B_TRUE); 1561da6c28aaSamw 1562da6c28aaSamw for (i = 0; i < SMBADM_NCMD; ++i) { 1563da6c28aaSamw curcmd = &smbadm_cmdtable[i]; 1564da6c28aaSamw if (strcasecmp(argv[1], curcmd->name) == 0) { 1565da6c28aaSamw if (argc > 2) { 1566da6c28aaSamw /* cmd subcmd --help/-? */ 1567da6c28aaSamw if (strcmp(argv[2], "-?") == 0 || 1568da6c28aaSamw strcmp(argv[2], "--help") == 0 || 1569da6c28aaSamw strcmp(argv[2], "-h") == 0) 1570da6c28aaSamw smbadm_usage(B_TRUE); 1571da6c28aaSamw } 1572da6c28aaSamw 157396a62adaSjoyce mcintosh if (!smbadm_checkauth(curcmd->auth)) { 157496a62adaSjoyce mcintosh (void) fprintf(stderr, 157596a62adaSjoyce mcintosh gettext("%s: %s: authorization denied\n"), 157696a62adaSjoyce mcintosh progname, curcmd->name); 157796a62adaSjoyce mcintosh return (1); 157896a62adaSjoyce mcintosh } 157996a62adaSjoyce mcintosh 15803db3f65cSamw if ((ret = smbadm_init()) != 0) 1581faa1795aSjb return (ret); 1582dc20a302Sas 1583dc20a302Sas ret = curcmd->func(argc - 1, &argv[1]); 1584faa1795aSjb 15853db3f65cSamw smbadm_fini(); 1586dc20a302Sas return (ret); 1587da6c28aaSamw } 1588da6c28aaSamw } 1589da6c28aaSamw 1590da6c28aaSamw curcmd = NULL; 1591da6c28aaSamw (void) fprintf(stderr, gettext("unknown subcommand (%s)\n"), argv[1]); 1592da6c28aaSamw smbadm_usage(B_FALSE); 1593da6c28aaSamw return (2); 1594da6c28aaSamw } 1595da6c28aaSamw 1596faa1795aSjb static int 15973db3f65cSamw smbadm_init(void) 1598faa1795aSjb { 1599faa1795aSjb int rc; 1600faa1795aSjb 16013db3f65cSamw switch (curcmd->flags & SMBADM_CMDF_TYPEMASK) { 16023db3f65cSamw case SMBADM_CMDF_GROUP: 1603faa1795aSjb if ((rc = smb_lgrp_start()) != SMB_LGRP_SUCCESS) { 1604faa1795aSjb (void) fprintf(stderr, 1605faa1795aSjb gettext("failed to initialize (%s)\n"), 1606faa1795aSjb smb_lgrp_strerror(rc)); 1607faa1795aSjb return (1); 1608faa1795aSjb } 16093db3f65cSamw break; 16103db3f65cSamw 16113db3f65cSamw case SMBADM_CMDF_USER: 16123db3f65cSamw smb_pwd_init(B_FALSE); 16133db3f65cSamw break; 16143db3f65cSamw 16153db3f65cSamw default: 16163db3f65cSamw break; 1617faa1795aSjb } 1618faa1795aSjb 1619faa1795aSjb return (0); 1620faa1795aSjb } 1621faa1795aSjb 1622faa1795aSjb static void 16233db3f65cSamw smbadm_fini(void) 1624faa1795aSjb { 16253db3f65cSamw switch (curcmd->flags & SMBADM_CMDF_TYPEMASK) { 16263db3f65cSamw case SMBADM_CMDF_GROUP: 1627faa1795aSjb smb_lgrp_stop(); 16283db3f65cSamw break; 16293db3f65cSamw 16303db3f65cSamw case SMBADM_CMDF_USER: 16313db3f65cSamw smb_pwd_fini(); 16323db3f65cSamw break; 16333db3f65cSamw 16343db3f65cSamw default: 16353db3f65cSamw break; 1636faa1795aSjb } 1637faa1795aSjb } 1638faa1795aSjb 163996a62adaSjoyce mcintosh static boolean_t 164096a62adaSjoyce mcintosh smbadm_checkauth(const char *auth) 164196a62adaSjoyce mcintosh { 164296a62adaSjoyce mcintosh struct passwd *pw; 164396a62adaSjoyce mcintosh 164496a62adaSjoyce mcintosh if ((pw = getpwuid(getuid())) == NULL) 164596a62adaSjoyce mcintosh return (B_FALSE); 164696a62adaSjoyce mcintosh 164796a62adaSjoyce mcintosh if (chkauthattr(auth, pw->pw_name) == 0) 164896a62adaSjoyce mcintosh return (B_FALSE); 164996a62adaSjoyce mcintosh 165096a62adaSjoyce mcintosh return (B_TRUE); 165196a62adaSjoyce mcintosh } 165296a62adaSjoyce mcintosh 1653da6c28aaSamw static boolean_t 1654da6c28aaSamw smbadm_prop_validate(smbadm_prop_t *prop, boolean_t chkval) 1655da6c28aaSamw { 1656da6c28aaSamw smbadm_prop_handle_t *pinfo; 1657da6c28aaSamw int i; 1658da6c28aaSamw 1659da6c28aaSamw for (i = 0; i < SMBADM_NPROP; i++) { 1660da6c28aaSamw pinfo = &smbadm_ptable[i]; 1661da6c28aaSamw if (strcmp(pinfo->p_name, prop->p_name) == 0) { 1662da6c28aaSamw if (pinfo->p_chkfn && chkval) 1663da6c28aaSamw return (pinfo->p_chkfn(prop)); 1664da6c28aaSamw 1665da6c28aaSamw return (B_TRUE); 1666da6c28aaSamw } 1667da6c28aaSamw } 1668da6c28aaSamw 16698d7e4166Sjose borrego (void) fprintf(stderr, gettext("unrecognized property '%s'\n"), 16708d7e4166Sjose borrego prop->p_name); 1671da6c28aaSamw 1672da6c28aaSamw return (B_FALSE); 1673da6c28aaSamw } 1674da6c28aaSamw 1675da6c28aaSamw static int 1676da6c28aaSamw smbadm_prop_parse(char *arg, smbadm_prop_t *prop) 1677da6c28aaSamw { 1678da6c28aaSamw boolean_t parse_value; 1679da6c28aaSamw char *equal; 1680da6c28aaSamw 1681da6c28aaSamw if (arg == NULL) 1682da6c28aaSamw return (2); 1683da6c28aaSamw 1684da6c28aaSamw prop->p_name = prop->p_value = NULL; 1685da6c28aaSamw 1686da6c28aaSamw if (strcmp(curcmd->name, "set") == 0) 1687da6c28aaSamw parse_value = B_TRUE; 1688da6c28aaSamw else 1689da6c28aaSamw parse_value = B_FALSE; 1690da6c28aaSamw 1691da6c28aaSamw prop->p_name = arg; 1692da6c28aaSamw 1693da6c28aaSamw if (parse_value) { 1694da6c28aaSamw equal = strchr(arg, '='); 1695da6c28aaSamw if (equal == NULL) 1696da6c28aaSamw return (2); 1697da6c28aaSamw 1698da6c28aaSamw *equal++ = '\0'; 1699da6c28aaSamw prop->p_value = equal; 1700da6c28aaSamw } 1701da6c28aaSamw 1702da6c28aaSamw if (smbadm_prop_validate(prop, parse_value) == B_FALSE) 1703da6c28aaSamw return (2); 1704da6c28aaSamw 1705da6c28aaSamw return (0); 1706da6c28aaSamw } 1707da6c28aaSamw 1708da6c28aaSamw static smbadm_prop_handle_t * 1709da6c28aaSamw smbadm_prop_gethandle(char *pname) 1710da6c28aaSamw { 1711da6c28aaSamw int i; 1712da6c28aaSamw 1713da6c28aaSamw for (i = 0; i < SMBADM_NPROP; i++) 1714da6c28aaSamw if (strcmp(pname, smbadm_ptable[i].p_name) == 0) 1715da6c28aaSamw return (&smbadm_ptable[i]); 1716da6c28aaSamw 1717da6c28aaSamw return (NULL); 1718da6c28aaSamw } 1719da6c28aaSamw 1720da6c28aaSamw static int 1721da6c28aaSamw smbadm_setprop_desc(char *gname, smbadm_prop_t *prop) 1722da6c28aaSamw { 1723dc20a302Sas int status; 1724da6c28aaSamw 1725dc20a302Sas status = smb_lgrp_setcmnt(gname, prop->p_value); 1726dc20a302Sas if (status != SMB_LGRP_SUCCESS) { 1727da6c28aaSamw (void) fprintf(stderr, 1728da6c28aaSamw gettext("failed to modify the group description (%s)\n"), 1729dc20a302Sas smb_lgrp_strerror(status)); 1730da6c28aaSamw return (1); 1731da6c28aaSamw } 1732da6c28aaSamw 17338d7e4166Sjose borrego (void) printf(gettext("%s: description modified\n"), gname); 1734da6c28aaSamw return (0); 1735da6c28aaSamw } 1736da6c28aaSamw 1737da6c28aaSamw static int 1738da6c28aaSamw smbadm_getprop_desc(char *gname, smbadm_prop_t *prop) 1739da6c28aaSamw { 1740dc20a302Sas char *cmnt = NULL; 1741dc20a302Sas int status; 1742da6c28aaSamw 1743dc20a302Sas status = smb_lgrp_getcmnt(gname, &cmnt); 1744dc20a302Sas if (status != SMB_LGRP_SUCCESS) { 1745da6c28aaSamw (void) fprintf(stderr, 1746dc20a302Sas gettext("failed to get the group description (%s)\n"), 1747dc20a302Sas smb_lgrp_strerror(status)); 1748da6c28aaSamw return (1); 1749da6c28aaSamw } 1750da6c28aaSamw 1751dc20a302Sas (void) printf(gettext("\t%s: %s\n"), prop->p_name, cmnt); 1752dc20a302Sas free(cmnt); 1753da6c28aaSamw return (0); 1754da6c28aaSamw } 1755da6c28aaSamw 1756da6c28aaSamw static int 1757dc20a302Sas smbadm_group_setpriv(char *gname, uint8_t priv_id, smbadm_prop_t *prop) 1758da6c28aaSamw { 1759dc20a302Sas boolean_t enable; 1760dc20a302Sas int status; 1761da6c28aaSamw int ret; 1762da6c28aaSamw 1763da6c28aaSamw if (strcasecmp(prop->p_value, "on") == 0) { 1764da6c28aaSamw (void) printf(gettext("Enabling %s privilege "), prop->p_name); 1765dc20a302Sas enable = B_TRUE; 1766da6c28aaSamw } else { 1767da6c28aaSamw (void) printf(gettext("Disabling %s privilege "), prop->p_name); 1768dc20a302Sas enable = B_FALSE; 1769da6c28aaSamw } 1770da6c28aaSamw 1771dc20a302Sas status = smb_lgrp_setpriv(gname, priv_id, enable); 1772dc20a302Sas if (status == SMB_LGRP_SUCCESS) { 1773da6c28aaSamw (void) printf(gettext("succeeded\n")); 1774da6c28aaSamw ret = 0; 1775da6c28aaSamw } else { 1776dc20a302Sas (void) printf(gettext("failed: %s\n"), 1777dc20a302Sas smb_lgrp_strerror(status)); 1778da6c28aaSamw ret = 1; 1779da6c28aaSamw } 1780da6c28aaSamw 1781da6c28aaSamw return (ret); 1782da6c28aaSamw } 1783da6c28aaSamw 1784da6c28aaSamw static int 1785dc20a302Sas smbadm_group_getpriv(char *gname, uint8_t priv_id, smbadm_prop_t *prop) 1786da6c28aaSamw { 1787dc20a302Sas boolean_t enable; 1788dc20a302Sas int status; 1789da6c28aaSamw 1790dc20a302Sas status = smb_lgrp_getpriv(gname, priv_id, &enable); 1791dc20a302Sas if (status != SMB_LGRP_SUCCESS) { 1792da6c28aaSamw (void) fprintf(stderr, gettext("failed to get %s (%s)\n"), 1793dc20a302Sas prop->p_name, smb_lgrp_strerror(status)); 1794da6c28aaSamw return (1); 1795da6c28aaSamw } 1796da6c28aaSamw 1797dc20a302Sas (void) printf(gettext("\t%s: %s\n"), prop->p_name, 1798dc20a302Sas (enable) ? "On" : "Off"); 1799da6c28aaSamw 1800da6c28aaSamw return (0); 1801da6c28aaSamw } 1802da6c28aaSamw 1803da6c28aaSamw static int 1804da6c28aaSamw smbadm_setprop_tkowner(char *gname, smbadm_prop_t *prop) 1805da6c28aaSamw { 1806da6c28aaSamw return (smbadm_group_setpriv(gname, SE_TAKE_OWNERSHIP_LUID, prop)); 1807da6c28aaSamw } 1808da6c28aaSamw 1809da6c28aaSamw static int 1810da6c28aaSamw smbadm_getprop_tkowner(char *gname, smbadm_prop_t *prop) 1811da6c28aaSamw { 1812da6c28aaSamw return (smbadm_group_getpriv(gname, SE_TAKE_OWNERSHIP_LUID, prop)); 1813da6c28aaSamw } 1814da6c28aaSamw 1815da6c28aaSamw static int 1816da6c28aaSamw smbadm_setprop_backup(char *gname, smbadm_prop_t *prop) 1817da6c28aaSamw { 1818da6c28aaSamw return (smbadm_group_setpriv(gname, SE_BACKUP_LUID, prop)); 1819da6c28aaSamw } 1820da6c28aaSamw 1821da6c28aaSamw static int 1822da6c28aaSamw smbadm_getprop_backup(char *gname, smbadm_prop_t *prop) 1823da6c28aaSamw { 1824da6c28aaSamw return (smbadm_group_getpriv(gname, SE_BACKUP_LUID, prop)); 1825da6c28aaSamw } 1826da6c28aaSamw 1827da6c28aaSamw static int 1828da6c28aaSamw smbadm_setprop_restore(char *gname, smbadm_prop_t *prop) 1829da6c28aaSamw { 1830da6c28aaSamw return (smbadm_group_setpriv(gname, SE_RESTORE_LUID, prop)); 1831da6c28aaSamw } 1832da6c28aaSamw 1833da6c28aaSamw static int 1834da6c28aaSamw smbadm_getprop_restore(char *gname, smbadm_prop_t *prop) 1835da6c28aaSamw { 1836da6c28aaSamw return (smbadm_group_getpriv(gname, SE_RESTORE_LUID, prop)); 1837da6c28aaSamw } 1838da6c28aaSamw 1839da6c28aaSamw static boolean_t 1840da6c28aaSamw smbadm_chkprop_priv(smbadm_prop_t *prop) 1841da6c28aaSamw { 1842da6c28aaSamw if (prop->p_value == NULL || *prop->p_value == '\0') { 1843da6c28aaSamw (void) fprintf(stderr, 1844da6c28aaSamw gettext("missing value for '%s'\n"), prop->p_name); 1845da6c28aaSamw return (B_FALSE); 1846da6c28aaSamw } 1847da6c28aaSamw 1848da6c28aaSamw if (strcasecmp(prop->p_value, "on") == 0) 1849da6c28aaSamw return (B_TRUE); 1850da6c28aaSamw 1851da6c28aaSamw if (strcasecmp(prop->p_value, "off") == 0) 1852da6c28aaSamw return (B_TRUE); 1853da6c28aaSamw 1854da6c28aaSamw (void) fprintf(stderr, 1855da6c28aaSamw gettext("%s: unrecognized value for '%s' property\n"), 1856da6c28aaSamw prop->p_value, prop->p_name); 1857da6c28aaSamw 1858da6c28aaSamw return (B_FALSE); 1859da6c28aaSamw } 1860da6c28aaSamw 1861da6c28aaSamw static const char * 1862da6c28aaSamw smbadm_pwd_strerror(int error) 1863da6c28aaSamw { 1864da6c28aaSamw switch (error) { 1865da6c28aaSamw case SMB_PWE_SUCCESS: 1866da6c28aaSamw return (gettext("Success.")); 1867da6c28aaSamw 1868da6c28aaSamw case SMB_PWE_USER_UNKNOWN: 1869da6c28aaSamw return (gettext("User does not exist.")); 1870da6c28aaSamw 1871da6c28aaSamw case SMB_PWE_USER_DISABLE: 18728d7e4166Sjose borrego return (gettext("User is disabled.")); 1873da6c28aaSamw 1874da6c28aaSamw case SMB_PWE_CLOSE_FAILED: 1875da6c28aaSamw case SMB_PWE_OPEN_FAILED: 1876da6c28aaSamw case SMB_PWE_WRITE_FAILED: 1877da6c28aaSamw case SMB_PWE_UPDATE_FAILED: 1878da6c28aaSamw return (gettext("Unexpected failure. " 1879da6c28aaSamw "SMB password database unchanged.")); 1880da6c28aaSamw 1881da6c28aaSamw case SMB_PWE_STAT_FAILED: 1882da6c28aaSamw return (gettext("stat of SMB password file failed.")); 1883da6c28aaSamw 1884da6c28aaSamw case SMB_PWE_BUSY: 1885da6c28aaSamw return (gettext("SMB password database busy. " 1886da6c28aaSamw "Try again later.")); 1887da6c28aaSamw 1888da6c28aaSamw case SMB_PWE_DENIED: 1889da6c28aaSamw return (gettext("Operation not permitted.")); 1890da6c28aaSamw 1891da6c28aaSamw case SMB_PWE_SYSTEM_ERROR: 1892da6c28aaSamw return (gettext("System error.")); 18933db3f65cSamw 18943db3f65cSamw default: 18953db3f65cSamw break; 1896da6c28aaSamw } 1897da6c28aaSamw 1898da6c28aaSamw return (gettext("Unknown error code.")); 1899da6c28aaSamw } 1900da6c28aaSamw 1901da6c28aaSamw /* 1902da6c28aaSamw * Enable libumem debugging by default on DEBUG builds. 1903da6c28aaSamw */ 1904da6c28aaSamw #ifdef DEBUG 1905da6c28aaSamw const char * 1906da6c28aaSamw _umem_debug_init(void) 1907da6c28aaSamw { 1908da6c28aaSamw return ("default,verbose"); /* $UMEM_DEBUG setting */ 1909da6c28aaSamw } 1910da6c28aaSamw 1911da6c28aaSamw const char * 1912da6c28aaSamw _umem_logging_init(void) 1913da6c28aaSamw { 1914da6c28aaSamw return ("fail,contents"); /* $UMEM_LOGGING setting */ 1915da6c28aaSamw } 1916da6c28aaSamw #endif 1917