/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2014 Nexenta Systems, Inc. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * default timeout (TTL) values (in second) for root and link */ #define DFS_ROOT_TIMEOUT 300 #define DFS_LINK_TIMEOUT 1800 /* * DFS link data format in reparse point * * ver:state:prop:timeout:guid:ntarget:cmntlen:comment * [[:tserver:tshare:tstate:pclass:prank]...] */ #define DFS_LINK_V1 1 #define DFS_LINK_HDR_NFIELDS 7 /* # fields in header section */ #define DFS_LINK_TRGT_NFIELDS 5 /* # fields for each target */ #define DFS_ROOT_XATTR "SUNWdfs.rootinfo" #define DFS_INFO_ALL 0 static void *dfs_intr_hdl = NULL; static struct { int (*dfsops_remote_count)(uint32_t *); } dfs_intr_ops; /* * Namespace cache * * Caches links' UNC and filesystem path where the key is the UNC path. */ static smb_cache_t dfs_nscache; static char dfs_nbname[NETBIOS_NAME_SZ]; /* * The name of cached namespace. This will be the only * exported namespace until hosting multiple namespaces * is supported */ static char dfs_cached_ns[MAXNAMELEN]; static mutex_t dfs_nsmtx; /* * Lock for accessing root information (extended attribute) */ static rwlock_t dfs_root_rwl; extern uint32_t srvsvc_shr_setdfsroot(smb_share_t *, boolean_t); /* * Namespace functions */ static boolean_t dfs_namespace_findlink(const char *, char *, char *, size_t); static void *dfs_namespace_cache(void *); static boolean_t dfs_namespace_iscached(const char *); /* * Root functions */ static int dfs_root_add(const char *, dfs_info_t *); static uint32_t dfs_root_remove(const char *); static uint32_t dfs_root_encode(dfs_info_t *, char **, size_t *); static uint32_t dfs_root_decode(dfs_info_t *, char *, size_t, uint32_t); static uint32_t dfs_root_isvalidstate(uint32_t); static int dfs_root_xopen(const char *, int); static void dfs_root_xclose(int); static uint32_t dfs_root_xwrite(int, dfs_info_t *); static uint32_t dfs_root_xread(int, dfs_info_t *, uint32_t); /* * Link functions */ static uint32_t dfs_link_encode(dfs_info_t *, char *, size_t); static uint32_t dfs_link_decode(dfs_info_t *, char *, uint32_t); static uint32_t dfs_link_commit(const char *, dfs_info_t *); static boolean_t dfs_link_isvalidstate(uint32_t); /* * Target functions */ static void dfs_target_init(dfs_target_t *, const char *, const char *, uint32_t); static int dfs_target_find(dfs_target_t *, uint32_t, const char *, const char *); static boolean_t dfs_target_isvalidstate(uint32_t); /* * Cache functions */ static uint32_t dfs_cache_add_byunc(const char *, const char *, uint32_t); static void dfs_cache_populate(const char *, const char *); static int dfs_cache_cmp(const void *, const void *); static void dfs_cache_flush(const char *); static uint32_t dfs_cache_nscount(void); /* * Utility functions */ static boolean_t dfs_path_isdir(const char *); static uint32_t dfs_modinfo(uint32_t, dfs_info_t *, dfs_info_t *, uint32_t); /* * DFS module initializationr: * * - creates the namespace cache * - gets system's NetBIOS name */ void dfs_init(void) { smb_cache_create(&dfs_nscache, 0, dfs_cache_cmp, free, bcopy, sizeof (dfs_nscnode_t)); if (smb_getnetbiosname(dfs_nbname, sizeof (dfs_nbname)) != 0) { syslog(LOG_ERR, "dfs: can't get machine name"); return; } bzero((void *)&dfs_intr_ops, sizeof (dfs_intr_ops)); if ((dfs_intr_hdl = smb_dlopen()) == NULL) return; if ((dfs_intr_ops.dfsops_remote_count = (int (*)())dlsym(dfs_intr_hdl, "smb_dfs_remote_count")) == NULL) { smb_dlclose(dfs_intr_hdl); dfs_intr_hdl = NULL; bzero((void *)&dfs_intr_ops, sizeof (dfs_intr_ops)); } } /* * DFS module cleanup: * * - destroys the namespace cache */ void dfs_fini(void) { smb_dlclose(dfs_intr_hdl); smb_cache_destroy(&dfs_nscache); } /* * To successfully handle some of link/root requests, some * file system operations need to be performed. These operations * should take place on behalf of the connected user (typically * Administrator) and to do so we need to have an infrastructure * in place so that smbd can act as a client and sends request to * the kernel. Right now, we lack this infrastructure, so we make * a compromise by temporarily enabling some privileges for smbd * to be able to fulfill various link/root requests. */ void dfs_setpriv(priv_op_t op) { (void) priv_set(op, PRIV_EFFECTIVE, PRIV_FILE_DAC_READ, PRIV_FILE_DAC_WRITE, PRIV_FILE_DAC_EXECUTE, PRIV_FILE_DAC_SEARCH, NULL); } /* * ======================== * Namespace API (public) * ======================== */ /* * Launches a thread to cache the specified namespace */ void dfs_namespace_load(const char *name) { pthread_t thr; pthread_attr_t tattr; char *rootshr; int rc; if ((rootshr = strdup(name)) == NULL) { syslog(LOG_ERR, "dfs: failed to load %s namespace (no memory)", name); return; } (void) pthread_attr_init(&tattr); (void) pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED); rc = pthread_create(&thr, &tattr, dfs_namespace_cache, rootshr); (void) pthread_attr_destroy(&tattr); if (rc != 0) syslog(LOG_ERR, "dfs: fail to loading %s namespace (%d)", name, rc); } /* * Flushes the cache when a DFS root share is removed */ void /*ARGSUSED*/ dfs_namespace_unload(const char *name) { dfs_cache_flush(name); } /* * Returns the file system path for the given share if it * is a DFS root share. * If 'path' is NULL, this function only indicates whether * or not the given share represents a DFS namespace */ uint32_t dfs_namespace_path(const char *name, char *path, size_t pathsz) { smb_share_t si; if (smb_shr_get((char *)name, &si) != NERR_Success) return (ERROR_NOT_FOUND); if ((si.shr_flags & SMB_SHRF_DFSROOT) == 0) return (ERROR_NOT_FOUND); if (!dfs_namespace_iscached(name)) return (ERROR_NOT_FOUND); if (path != NULL) (void) strlcpy(path, si.shr_path, pathsz); return (ERROR_SUCCESS); } /* * Returns the number of DFS root shares i.e. the number * of standalone namespaces. */ uint32_t dfs_namespace_count(void) { uint32_t nroot = 0; int rc; if (dfs_intr_ops.dfsops_remote_count != NULL && (rc = dfs_intr_ops.dfsops_remote_count(&nroot)) != 0) { /* * If this call fails, let's assume there's at least one root * namespace already configured. The interposer library cannot * confirm or deny the presence of a namespace, so let's take * the safe approach and assume one exists. */ nroot = 1; syslog(LOG_WARNING, "dfs: dfsops_remote_count() failed: %d, " "assuming one namespace exists", rc); } nroot += dfs_cache_nscount(); return (nroot); } /* * Creates a DFS root with the given name and comment. * * This function does not create the root share, it * should already exist. */ uint32_t dfs_namespace_add(const char *rootshr, const char *cmnt) { dfs_info_t info; dfs_target_t t; smb_share_t si; uuid_t uuid; uint32_t status; if (*rootshr == '\\') { /* Windows has a special case here! */ return (ERROR_BAD_PATHNAME); } if (smb_shr_get((char *)rootshr, &si) != NERR_Success) return (NERR_NetNameNotFound); (void) mutex_lock(&dfs_nsmtx); if (smb_strcasecmp(dfs_cached_ns, rootshr, 0) == 0) { /* This DFS root is already exported */ (void) mutex_unlock(&dfs_nsmtx); return (ERROR_FILE_EXISTS); } if (*dfs_cached_ns != '\0') { syslog(LOG_WARNING, "dfs: trying to add %s namespace." " Only one standalone namespace is supported." " A namespace is already exported for %s", rootshr, dfs_cached_ns); (void) mutex_unlock(&dfs_nsmtx); return (ERROR_NOT_SUPPORTED); } bzero(&info, sizeof (info)); if (cmnt) (void) strlcpy(info.i_comment, cmnt, sizeof (info.i_comment)); info.i_state = DFS_VOLUME_STATE_OK | DFS_VOLUME_FLAVOR_STANDALONE; info.i_timeout = DFS_ROOT_TIMEOUT; info.i_propflags = 0; uuid_generate_random(uuid); uuid_unparse(uuid, info.i_guid); dfs_target_init(&t, dfs_nbname, rootshr, DFS_STORAGE_STATE_ONLINE); info.i_ntargets = 1; info.i_targets = &t; if ((status = dfs_root_add(si.shr_path, &info)) != ERROR_SUCCESS) { (void) mutex_unlock(&dfs_nsmtx); return (status); } status = srvsvc_shr_setdfsroot(&si, B_TRUE); if (status == ERROR_SUCCESS) { (void) dfs_cache_add_byname(rootshr, NULL, DFS_OBJECT_ROOT); (void) strlcpy(dfs_cached_ns, rootshr, sizeof (dfs_cached_ns)); (void) smb_config_setnum(SMB_CI_DFS_STDROOT_NUM, 1); } (void) mutex_unlock(&dfs_nsmtx); return (status); } /* * Removes the namespace and all the links in it. */ uint32_t dfs_namespace_remove(const char *name) { smb_cache_cursor_t cursor; dfs_nscnode_t nscnode; smb_share_t si; uint32_t status; if (smb_shr_get((char *)name, &si) != NERR_Success) return (ERROR_NOT_FOUND); if ((si.shr_flags & SMB_SHRF_DFSROOT) == 0) return (ERROR_NOT_FOUND); if ((status = dfs_root_remove(si.shr_path)) != ERROR_SUCCESS) return (status); status = srvsvc_shr_setdfsroot(&si, B_FALSE); if (status != ERROR_SUCCESS) syslog(LOG_WARNING, "dfs: failed to disable root share %s (%d)", name, status); if (!dfs_namespace_iscached(name)) return (ERROR_SUCCESS); smb_cache_iterinit(&dfs_nscache, &cursor); while (smb_cache_iterate(&dfs_nscache, &cursor, &nscnode)) { if (nscnode.nsc_type == DFS_OBJECT_ROOT) continue; status = dfs_link_remove(nscnode.nsc_fspath, NULL, NULL); if (status != ERROR_SUCCESS) syslog(LOG_WARNING, "dfs: failed to remove %s (%d)", nscnode.nsc_fspath, status); } dfs_cache_flush(name); /* TODO: remove empty dirs */ return (ERROR_SUCCESS); } /* * Determines the DFS namespace flavor. */ uint32_t dfs_namespace_getflavor(const char *name) { char rootdir[DFS_PATH_MAX]; dfs_info_t info; if (dfs_namespace_path(name, rootdir, DFS_PATH_MAX) != ERROR_SUCCESS) return (0); /* get flavor info from state info (info level 2) */ if (dfs_root_getinfo(rootdir, &info, 2) != ERROR_SUCCESS) return (0); return (info.i_state & DFS_VOLUME_FLAVORS); } /* * ================== * Root API (public) * ================== */ /* * Retrieves the information of the root specified by its path. * * Info level (1) only needs the UNC path which is not stored, * it is constructed so the function will return without * accessing the backend storage. */ uint32_t dfs_root_getinfo(const char *rootdir, dfs_info_t *info, uint32_t infolvl) { uint32_t status = ERROR_INTERNAL_ERROR; int xfd; bzero(info, sizeof (dfs_info_t)); info->i_type = DFS_OBJECT_ROOT; if (infolvl == 1) return (ERROR_SUCCESS); (void) rw_rdlock(&dfs_root_rwl); if ((xfd = dfs_root_xopen(rootdir, O_RDONLY)) > 0) { status = dfs_root_xread(xfd, info, infolvl); dfs_root_xclose(xfd); } (void) rw_unlock(&dfs_root_rwl); return (status); } /* * Sets the provided information for the specified root or root target. * Root is specified by 'rootdir' and the target is specified by * (t_server, t_share) pair. Only information items needed for given * information level (infolvl) is valid in the passed DFS info structure * 'info'. */ uint32_t dfs_root_setinfo(const char *rootdir, dfs_info_t *info, uint32_t infolvl) { dfs_info_t curinfo; uint32_t status = ERROR_SUCCESS; int xfd; (void) rw_wrlock(&dfs_root_rwl); if ((xfd = dfs_root_xopen(rootdir, O_RDWR)) < 0) { (void) rw_unlock(&dfs_root_rwl); return (ERROR_INTERNAL_ERROR); } status = dfs_root_xread(xfd, &curinfo, DFS_INFO_ALL); if (status != ERROR_SUCCESS) { dfs_root_xclose(xfd); (void) rw_unlock(&dfs_root_rwl); return (status); } status = dfs_modinfo(DFS_OBJECT_ROOT, &curinfo, info, infolvl); if (status == ERROR_SUCCESS) status = dfs_root_xwrite(xfd, &curinfo); dfs_root_xclose(xfd); (void) rw_unlock(&dfs_root_rwl); dfs_info_free(&curinfo); return (status); } /* * ================== * Link API (public) * ================== */ /* * Gets the status of the given path as a link */ uint32_t dfs_link_stat(const char *path, uint32_t *stat) { if (smb_reparse_stat(path, stat) != 0) return (ERROR_INTERNAL_ERROR); switch (*stat) { case SMB_REPARSE_NOTFOUND: *stat = DFS_STAT_NOTFOUND; break; case SMB_REPARSE_NOTREPARSE: *stat = DFS_STAT_NOTLINK; break; case SMB_REPARSE_ISREPARSE: *stat = DFS_STAT_ISREPARSE; if (smb_reparse_svcget(path, DFS_REPARSE_SVCTYPE, NULL) == 0) *stat = DFS_STAT_ISDFS; break; default: *stat = DFS_STAT_UNKNOWN; break; } return (ERROR_SUCCESS); } /* * Creates a new DFS link or adds a new target to an existing link */ uint32_t dfs_link_add(const char *path, const char *server, const char *share, const char *cmnt, uint32_t flags, boolean_t *newlink) { dfs_info_t info; dfs_target_t *t; int ntargets; uint32_t status; uint32_t stat; *newlink = B_FALSE; if ((status = dfs_link_stat(path, &stat)) != ERROR_SUCCESS) return (status); switch (stat) { case DFS_STAT_NOTFOUND: case DFS_STAT_ISREPARSE: /* Create a new DFS link */ status = dfs_link_getinfo(NULL, &info, DFS_INFO_ALL); if (status != ERROR_SUCCESS) return (status); (void) strlcpy(info.i_comment, (cmnt) ? cmnt : "", sizeof (info.i_comment)); *newlink = B_TRUE; break; case DFS_STAT_ISDFS: /* Add a target to an existing link */ if (flags & DFS_ADD_VOLUME) return (ERROR_FILE_EXISTS); status = dfs_link_getinfo(path, &info, DFS_INFO_ALL); if (status != ERROR_SUCCESS) return (status); break; case DFS_STAT_NOTLINK: /* specified path points to a non-reparse object */ return (ERROR_FILE_EXISTS); default: return (ERROR_INTERNAL_ERROR); } /* checks to see if the target already exists */ ntargets = info.i_ntargets; if (dfs_target_find(info.i_targets, ntargets, server, share) != -1) { dfs_info_free(&info); return (ERROR_FILE_EXISTS); } /* add the new target */ t = realloc(info.i_targets, (ntargets + 1) * sizeof (dfs_target_t)); if (t == NULL) { dfs_info_free(&info); return (ERROR_NOT_ENOUGH_MEMORY); } info.i_targets = t; dfs_target_init(&info.i_targets[ntargets], server, share, DFS_STORAGE_STATE_ONLINE); info.i_ntargets++; status = dfs_link_commit(path, &info); dfs_info_free(&info); return (status); } /* * Removes a link or a link target from a DFS namespace. A link can be * removed regardless of the number of targets associated with it. * * 'server' and 'share' parameters specify a target, so if they are NULL * it means the link should be removed, otherwise the specified target * is removed if found. */ uint32_t dfs_link_remove(const char *path, const char *server, const char *share) { dfs_info_t info; uint32_t status, stat; int rc, idx; if ((status = dfs_link_stat(path, &stat)) != ERROR_SUCCESS) return (status); if (stat != DFS_STAT_ISDFS) return (ERROR_NOT_FOUND); if (server == NULL && share == NULL) { /* remove the link */ if (smb_reparse_svcdel(path, DFS_REPARSE_SVCTYPE) != 0) return (ERROR_INTERNAL_ERROR); return (ERROR_SUCCESS); } /* remove the specified target in the link */ status = dfs_link_getinfo(path, &info, DFS_INFO_ALL); if (status != ERROR_SUCCESS) return (status); /* checks to see if the target exists */ idx = dfs_target_find(info.i_targets, info.i_ntargets, server, share); if (idx != -1) { bcopy(&info.i_targets[idx + 1], &info.i_targets[idx], (info.i_ntargets - idx - 1) * sizeof (dfs_target_t)); info.i_ntargets--; } else { dfs_info_free(&info); return (ERROR_FILE_NOT_FOUND); } if (info.i_ntargets == 0) { /* if last target, then remove the link */ rc = smb_reparse_svcdel(path, DFS_REPARSE_SVCTYPE); status = (rc == 0) ? ERROR_SUCCESS : ERROR_INTERNAL_ERROR; } else { status = dfs_link_commit(path, &info); } dfs_info_free(&info); return (status); } /* * Sets the provided information for the specified link or link target. * Link is specified by 'path' and the target is specified by * (t_server, t_share) pair. Only information items needed for given * information level (infolvl) is valid in the passed DFS info structure * 'info'. */ uint32_t dfs_link_setinfo(const char *path, dfs_info_t *info, uint32_t infolvl) { dfs_info_t curinfo; uint32_t status; status = dfs_link_getinfo(path, &curinfo, DFS_INFO_ALL); if (status != ERROR_SUCCESS) return (status); status = dfs_modinfo(DFS_OBJECT_LINK, &curinfo, info, infolvl); if (status == ERROR_SUCCESS) status = dfs_link_commit(path, &curinfo); dfs_info_free(&curinfo); return (status); } /* * Gets the DFS link info. * * If path is NULL, it just does some initialization. * * Info level (1) only needs the UNC path which is not * stored, it is constructed so the function will return * without accessing the backend storage. */ uint32_t dfs_link_getinfo(const char *path, dfs_info_t *info, uint32_t infolvl) { char *link_data; uint32_t status; uuid_t uuid; int rc; bzero(info, sizeof (dfs_info_t)); info->i_type = DFS_OBJECT_LINK; if (path == NULL) { info->i_state = DFS_VOLUME_STATE_OK; info->i_timeout = DFS_LINK_TIMEOUT; info->i_propflags = 0; uuid_generate_random(uuid); uuid_unparse(uuid, info->i_guid); return (ERROR_SUCCESS); } if (infolvl == 1) return (ERROR_SUCCESS); rc = smb_reparse_svcget(path, DFS_REPARSE_SVCTYPE, &link_data); if (rc != 0) return (ERROR_INTERNAL_ERROR); status = dfs_link_decode(info, link_data, infolvl); free(link_data); return (status); } /* * =================== * Cache API (public) * =================== */ /* * Adds an entry with given DFS name (root sharename) and relative path * to the share (relpath) and the specified entry type (i.e. root/link) * to the namespace cache. */ uint32_t dfs_cache_add_byname(const char *name, const char *relpath, uint32_t type) { char uncpath[DFS_PATH_MAX]; char fspath[DFS_PATH_MAX]; smb_share_t si; if (smb_shr_get((char *)name, &si) != NERR_Success) return (ERROR_NOT_FOUND); if (type == DFS_OBJECT_ROOT) { (void) snprintf(uncpath, DFS_PATH_MAX, "\\\\%s\\%s", dfs_nbname, name); return (dfs_cache_add_byunc(uncpath, si.shr_path, type)); } /* add link entry */ (void) snprintf(fspath, DFS_PATH_MAX, "%s/%s", si.shr_path, relpath); (void) snprintf(uncpath, DFS_PATH_MAX, "\\\\%s\\%s\\%s", dfs_nbname, name, relpath); /* relpath may contain '/' */ (void) strsubst(uncpath, '/', '\\'); return (dfs_cache_add_byunc(uncpath, fspath, type)); } /* * Removes the namespace cache entry for the given link * in the namespace ('name') with 'relpath' */ void dfs_cache_remove(const char *name, const char *relpath) { dfs_nscnode_t dn; (void) snprintf(dn.nsc_uncpath, sizeof (dn.nsc_uncpath), "\\\\%s\\%s\\%s", dfs_nbname, name, relpath); /* relpath may contain '/' */ (void) strsubst(dn.nsc_uncpath, '/', '\\'); smb_cache_remove(&dfs_nscache, &dn); } /* * Get the DFS data for the specified cache entry */ uint32_t dfs_cache_getinfo(dfs_nscnode_t *dn, dfs_info_t *info, uint32_t infolvl) { uint32_t status; if (dn->nsc_type == DFS_OBJECT_LINK) status = dfs_link_getinfo(dn->nsc_fspath, info, infolvl); else status = dfs_root_getinfo(dn->nsc_fspath, info, infolvl); (void) strlcpy(info->i_uncpath, dn->nsc_uncpath, sizeof (info->i_uncpath)); if (status == ERROR_SUCCESS) dfs_info_trace("dfs_cache_getinfo", info); return (status); } /* * Returns the number of cache entries i.e. the number of * root(s) and link(s) */ uint32_t dfs_cache_num(void) { return (smb_cache_num(&dfs_nscache)); } void dfs_cache_iterinit(smb_cache_cursor_t *cursor) { smb_cache_iterinit(&dfs_nscache, cursor); } boolean_t dfs_cache_iterate(smb_cache_cursor_t *cursor, dfs_nscnode_t *dn) { return (smb_cache_iterate(&dfs_nscache, cursor, dn)); } /* * ================== * Misc API (public) * ================== */ /* * This is the function that is called by smbd door server to * fullfil a GetReferrals request from smbsrv kernel module * * 'reftype' specifies the requested referral type. If it is * DFS_REFERRAL_ROOT then dfs_path should point to a namespace * root. If it is DFS_REFERRAL_LINK then dfs_path should CONTAIN * a link, in which case this function will find the link and * returns its target information. */ uint32_t dfs_get_referrals(const char *dfs_path, dfs_reftype_t reftype, dfs_info_t *referrals) { dfs_path_t path; smb_unc_t *unc; char linkpath[DFS_PATH_MAX]; uint32_t status; status = dfs_path_parse(&path, dfs_path, DFS_OBJECT_ANY); if (status != ERROR_SUCCESS) return (status); dfs_setpriv(PRIV_ON); referrals->i_type = path.p_type; switch (reftype) { case DFS_REFERRAL_ROOT: if (path.p_type != DFS_OBJECT_ROOT) { status = ERROR_INVALID_PARAMETER; break; } status = dfs_root_getinfo((const char *)path.p_fspath, referrals, DFS_INFO_ALL); (void) strlcpy(referrals->i_uncpath, dfs_path, DFS_PATH_MAX); break; case DFS_REFERRAL_LINK: if (path.p_type != DFS_OBJECT_LINK) { status = ERROR_INVALID_PARAMETER; break; } unc = &path.p_unc; if (!dfs_namespace_findlink(unc->unc_share, unc->unc_path, linkpath, DFS_PATH_MAX)) { status = ERROR_NOT_FOUND; break; } status = dfs_link_getinfo(linkpath, referrals, DFS_INFO_ALL); (void) snprintf(referrals->i_uncpath, DFS_PATH_MAX, "/%s/%s/%s", unc->unc_server, unc->unc_share, unc->unc_path); break; default: status = ERROR_INVALID_PARAMETER; break; } dfs_setpriv(PRIV_OFF); dfs_path_free(&path); return (status); } /* * Takes a DFS path in UNC format (dfs_path) and parse it into a dfs_path_t * structure. * * dfs_path_free() MUST be called to free the allocated memory in this * function. * * Returns: * * ERROR_INVALID_PARAMETER path is not a valid UNC or not valid for the * specified object type * ERROR_NOT_ENOUGH_MEMORY not enough memory to peform the parse * ERROR_NOT_FOUND namespace specified does not exist */ uint32_t dfs_path_parse(dfs_path_t *path, const char *dfs_path, uint32_t path_type) { char rootdir[DFS_PATH_MAX]; smb_unc_t *unc; uint32_t status = ERROR_SUCCESS; int rc; bzero(path, sizeof (dfs_path_t)); unc = &path->p_unc; rc = smb_unc_init(dfs_path, unc); switch (rc) { case EINVAL: return (ERROR_INVALID_PARAMETER); case ENOMEM: return (ERROR_NOT_ENOUGH_MEMORY); default: break; } if (dfs_namespace_path(unc->unc_share, rootdir, DFS_PATH_MAX) != ERROR_SUCCESS) { smb_unc_free(unc); return (ERROR_NOT_FOUND); } if (path_type == DFS_OBJECT_ANY) path->p_type = (unc->unc_path != NULL) ? DFS_OBJECT_LINK : DFS_OBJECT_ROOT; else path->p_type = path_type; switch (path->p_type) { case DFS_OBJECT_LINK: if ((unc->unc_path == NULL) || (*unc->unc_path == '\0')) status = ERROR_NOT_FOUND; else (void) snprintf(path->p_fspath, sizeof (path->p_fspath), "%s/%s", rootdir, unc->unc_path); break; case DFS_OBJECT_ROOT: if (unc->unc_path == NULL) (void) strlcpy(path->p_fspath, rootdir, sizeof (path->p_fspath)); else status = ERROR_INVALID_PARAMETER; break; default: status = ERROR_INVALID_PARAMETER; } if (status != ERROR_SUCCESS) smb_unc_free(unc); return (status); } /* * Frees the allocated memory for p_unc field of the passed path */ void dfs_path_free(dfs_path_t *path) { if (path != NULL) smb_unc_free(&path->p_unc); } /* * Free the allocated memory for targets in the given info * structure */ void dfs_info_free(dfs_info_t *info) { if (info) free(info->i_targets); } /* * Trace the given DFS info structure */ void dfs_info_trace(const char *msg, dfs_info_t *info) { dfs_target_t *t; int i; smb_tracef("%s", msg); if (info == NULL) return; smb_tracef("UNC\t%s", info->i_uncpath); smb_tracef("comment\t%s", info->i_comment); smb_tracef("GUID\t%s", info->i_guid); smb_tracef("state\t%X", info->i_state); smb_tracef("timeout\t%d", info->i_timeout); smb_tracef("props\t%X", info->i_propflags); smb_tracef("# targets\t%X", info->i_ntargets); if (info->i_targets == NULL) return; for (i = 0, t = info->i_targets; i < info->i_ntargets; i++, t++) { smb_tracef("[%d] \\\\%s\\%s", i, t->t_server, t->t_share); smb_tracef("[%d] state\t%X", i, t->t_state); smb_tracef("[%d] priority\t%d:%d", i, t->t_priority.p_class, t->t_priority.p_rank); } } /* * Search the path specified by 'relpath' to see if it contains * a DFS link starting from the last component. If a link is found * the full path is returned in 'linkpath' */ static boolean_t dfs_namespace_findlink(const char *name, char *relpath, char *linkpath, size_t bufsz) { char rootdir[DFS_PATH_MAX]; uint32_t stat; char *p; if (dfs_namespace_path(name, rootdir, DFS_PATH_MAX) != ERROR_SUCCESS) return (B_FALSE); (void) snprintf(linkpath, bufsz, "%s/%s", rootdir, relpath); for (;;) { if (dfs_link_stat(linkpath, &stat) != ERROR_SUCCESS) return (B_FALSE); if (stat == DFS_STAT_ISDFS) return (B_TRUE); if ((p = strrchr(relpath, '/')) == NULL) return (B_FALSE); *p = '\0'; (void) snprintf(linkpath, bufsz, "%s/%s", rootdir, relpath); } /*NOTREACHED*/ return (B_FALSE); } /* * Caches the specified namespace */ static void * dfs_namespace_cache(void *arg) { char *share = arg; char uncpath[DFS_PATH_MAX]; smb_share_t si; if (smb_shr_get(share, &si) != NERR_Success) { free(share); return (NULL); } /* * This check should be removed when multiple standalone * namespaces are supported. */ (void) mutex_lock(&dfs_nsmtx); if (*dfs_cached_ns != '\0') { syslog(LOG_WARNING, "dfs: trying to load %s namespace." " Only one standalone namespace is supported." " A namespace is already exported for %s", share, dfs_cached_ns); (void) mutex_unlock(&dfs_nsmtx); free(share); return (NULL); } (void) strlcpy(dfs_cached_ns, share, sizeof (dfs_cached_ns)); (void) smb_config_setnum(SMB_CI_DFS_STDROOT_NUM, 1); (void) mutex_unlock(&dfs_nsmtx); (void) snprintf(uncpath, DFS_PATH_MAX, "\\\\%s\\%s", dfs_nbname, share); (void) dfs_cache_add_byunc(uncpath, si.shr_path, DFS_OBJECT_ROOT); dfs_cache_populate(uncpath, si.shr_path); free(share); return (NULL); } /* * Checks whether the given name matches the name of * the cached namespace. */ static boolean_t dfs_namespace_iscached(const char *name) { boolean_t iscached; (void) mutex_lock(&dfs_nsmtx); iscached = (smb_strcasecmp(name, dfs_cached_ns, 0) == 0); (void) mutex_unlock(&dfs_nsmtx); return (iscached); } static int dfs_root_add(const char *rootdir, dfs_info_t *info) { uint32_t status = ERROR_INTERNAL_ERROR; int xfd; (void) rw_wrlock(&dfs_root_rwl); if ((xfd = dfs_root_xopen(rootdir, O_CREAT | O_TRUNC | O_RDWR)) > 0) { status = dfs_root_xwrite(xfd, info); dfs_root_xclose(xfd); } (void) rw_unlock(&dfs_root_rwl); return (status); } /* * Deletes the specified root information */ static uint32_t dfs_root_remove(const char *rootdir) { int attrdirfd; int err = 0; (void) rw_wrlock(&dfs_root_rwl); if ((attrdirfd = attropen(rootdir, ".", O_RDONLY)) > 0) { if (unlinkat(attrdirfd, DFS_ROOT_XATTR, 0) == -1) { if (errno != ENOENT) err = errno; } (void) close(attrdirfd); } else { err = errno; } (void) rw_unlock(&dfs_root_rwl); if (err != 0) { syslog(LOG_DEBUG, "dfs: failed to remove root info %s (%d)", rootdir, err); return (ERROR_INTERNAL_ERROR); } return (ERROR_SUCCESS); } /* * Opens DFS root directory's extended attribute with the given mode. */ static int dfs_root_xopen(const char *rootdir, int oflag) { int dfd; int xfd = -1; int err = 0; if ((dfd = open(rootdir, O_RDONLY)) > 0) { xfd = openat(dfd, DFS_ROOT_XATTR, oflag | O_XATTR, 0600); if (xfd == -1) err = errno; (void) close(dfd); } else { err = errno; } if (err != 0) { syslog(LOG_DEBUG, "dfs: failed to open root directory %s (%d)", rootdir, err); } return (xfd); } /* * Closes given extended attribute file descriptor */ static void dfs_root_xclose(int xfd) { (void) close(xfd); } /* * Writes the given DFS data in the DFS root directory's * extended attribute specified with xfd file descriptor. */ static uint32_t dfs_root_xwrite(int xfd, dfs_info_t *info) { size_t nbytes; char *buf = NULL; size_t buflen; uint32_t status; if ((status = dfs_root_encode(info, &buf, &buflen)) != ERROR_SUCCESS) return (status); (void) lseek(xfd, 0, SEEK_SET); nbytes = write(xfd, buf, buflen); free(buf); return ((nbytes == buflen) ? ERROR_SUCCESS : ERROR_INTERNAL_ERROR); } /* * Reads DFS root information from its directory extended attribute * and parse it into given dfs_info_t structure */ static uint32_t dfs_root_xread(int xfd, dfs_info_t *info, uint32_t infolvl) { struct stat statbuf; uint32_t status; char *buf; if (fstat(xfd, &statbuf) != 0) return (ERROR_INTERNAL_ERROR); if ((buf = malloc(statbuf.st_size)) == NULL) return (ERROR_NOT_ENOUGH_MEMORY); if (read(xfd, buf, statbuf.st_size) == statbuf.st_size) status = dfs_root_decode(info, buf, statbuf.st_size, infolvl); else status = ERROR_INTERNAL_ERROR; free(buf); return (status); } /* * Encodes (packs) DFS information in 'info' into a flat * buffer in a name-value format. This function allocates a * buffer with appropriate size to contain all the information * so the caller MUST free the allocated memory by calling free(). */ static uint32_t dfs_root_encode(dfs_info_t *info, char **buf, size_t *bufsz) { dfs_target_t *t; nvlist_t *nvl; int rc; if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) return (ERROR_NOT_ENOUGH_MEMORY); rc = nvlist_add_string(nvl, "comment", info->i_comment); rc |= nvlist_add_string(nvl, "guid", info->i_guid); rc |= nvlist_add_uint32(nvl, "state", info->i_state); rc |= nvlist_add_uint32(nvl, "timeout", info->i_timeout); rc |= nvlist_add_uint32(nvl, "propflags", info->i_propflags); t = info->i_targets; rc |= nvlist_add_string(nvl, "t_server", t->t_server); rc |= nvlist_add_string(nvl, "t_share", t->t_share); rc |= nvlist_add_uint32(nvl, "t_state", t->t_state); rc |= nvlist_add_uint32(nvl, "t_priority_class", t->t_priority.p_class); rc |= nvlist_add_uint16(nvl, "t_priority_rank", t->t_priority.p_rank); if (rc == 0) rc = nvlist_pack(nvl, buf, bufsz, NV_ENCODE_NATIVE, 0); nvlist_free(nvl); return ((rc == 0) ? ERROR_SUCCESS : ERROR_INTERNAL_ERROR); } /* * Decodes (unpack) provided buffer which contains a list of name-value * pairs into given dfs_info_t structure */ static uint32_t dfs_root_decode(dfs_info_t *info, char *buf, size_t bufsz, uint32_t infolvl) { nvlist_t *nvl; char *cmnt, *guid; char *t_server, *t_share; uint32_t t_state; uint32_t t_priority_class; uint16_t t_priority_rank; boolean_t decode_priority = B_FALSE; int rc; if (nvlist_unpack(buf, bufsz, &nvl, 0) != 0) return (ERROR_INTERNAL_ERROR); rc = nvlist_lookup_string(nvl, "comment", &cmnt); rc |= nvlist_lookup_string(nvl, "guid", &guid); rc |= nvlist_lookup_uint32(nvl, "state", &info->i_state); rc |= nvlist_lookup_uint32(nvl, "timeout", &info->i_timeout); rc |= nvlist_lookup_uint32(nvl, "propflags", &info->i_propflags); if (rc != 0) { nvlist_free(nvl); return (ERROR_INTERNAL_ERROR); } (void) strlcpy(info->i_comment, (cmnt) ? cmnt : "", sizeof (info->i_comment)); (void) strlcpy(info->i_guid, (guid) ? guid : "", sizeof (info->i_guid)); info->i_targets = NULL; info->i_ntargets = 1; switch (infolvl) { case DFS_INFO_ALL: case 3: case 4: /* need target information */ break; case 6: case 9: /* need target and priority information */ decode_priority = B_TRUE; break; default: nvlist_free(nvl); return (ERROR_SUCCESS); } info->i_targets = malloc(sizeof (dfs_target_t)); if (info->i_targets == NULL) { nvlist_free(nvl); return (ERROR_NOT_ENOUGH_MEMORY); } rc = nvlist_lookup_string(nvl, "t_server", &t_server); rc |= nvlist_lookup_string(nvl, "t_share", &t_share); rc |= nvlist_lookup_uint32(nvl, "t_state", &t_state); if (rc != 0) { nvlist_free(nvl); free(info->i_targets); return (ERROR_INTERNAL_ERROR); } dfs_target_init(info->i_targets, t_server, t_share, t_state); if (decode_priority) { rc = nvlist_lookup_uint32(nvl, "t_priority_class", &t_priority_class); if (rc == 0) rc = nvlist_lookup_uint16(nvl, "t_priority_rank", &t_priority_rank); if (rc != 0 && rc != ENOENT) { nvlist_free(nvl); free(info->i_targets); return (ERROR_INTERNAL_ERROR); } else if (rc == 0) { info->i_targets->t_priority.p_class = t_priority_class; info->i_targets->t_priority.p_rank = t_priority_rank; } } nvlist_free(nvl); return (ERROR_SUCCESS); } /* * Determines if the passed state is valid for a DFS root * * This is based on test results against Win2003 and in some cases * does not match [MS-DFSNM] spec. */ static uint32_t dfs_root_isvalidstate(uint32_t state) { switch (state) { case DFS_VOLUME_STATE_OK: case DFS_VOLUME_STATE_RESYNCHRONIZE: return (ERROR_SUCCESS); case DFS_VOLUME_STATE_INCONSISTENT: case DFS_VOLUME_STATE_FORCE_SYNC: return (ERROR_INVALID_PARAMETER); case DFS_VOLUME_STATE_OFFLINE: case DFS_VOLUME_STATE_ONLINE: case DFS_VOLUME_STATE_STANDBY: return (ERROR_NOT_SUPPORTED); default: break; } return (ERROR_INVALID_PARAMETER); } /* * Decodes the link info from given string buffer (buf) into * dfs_info_t structure. */ static uint32_t dfs_link_decode(dfs_info_t *info, char *buf, uint32_t infolvl) { char *lfield[DFS_LINK_HDR_NFIELDS]; dfs_target_t *t; uint32_t linkver; uint32_t cmntlen; uint32_t cpylen; int i, j; /* * Header format * ver:state:prop:timeout:guid:ntarget:cmntlen:comment: */ for (i = 0; i < DFS_LINK_HDR_NFIELDS; i++) { if ((lfield[i] = strsep((char **)&buf, ":")) == NULL) return (ERROR_INVALID_DATA); } i = 0; linkver = strtoul(lfield[i++], NULL, 10); if (linkver != DFS_LINK_V1) return (ERROR_INVALID_DATA); info->i_state = strtoul(lfield[i++], NULL, 10); info->i_propflags = strtoul(lfield[i++], NULL, 10); info->i_timeout = strtoul(lfield[i++], NULL, 10); (void) strlcpy(info->i_guid, lfield[i++], sizeof (info->i_guid)); info->i_ntargets = strtoul(lfield[i++], NULL, 10); info->i_targets = NULL; cpylen = cmntlen = strtoul(lfield[i++], NULL, 10); if (cmntlen > sizeof (info->i_comment)) cpylen = sizeof (info->i_comment); else if (cmntlen != 0) cpylen = cmntlen + 1; (void) strlcpy(info->i_comment, buf, cpylen); buf += (cmntlen + 1); switch (infolvl) { case DFS_INFO_ALL: case 3: case 4: case 6: case 9: /* need target information */ break; default: return (ERROR_SUCCESS); } info->i_targets = calloc(info->i_ntargets, sizeof (dfs_target_t)); if (info->i_targets == NULL) return (ERROR_NOT_ENOUGH_MEMORY); /* * Format for each target * server:share:state:class:rank */ for (i = 0, t = info->i_targets; i < info->i_ntargets; i++, t++) { for (j = 0; j < DFS_LINK_TRGT_NFIELDS; j++) { if ((lfield[j] = strsep((char **)&buf, ":")) == NULL) { dfs_info_free(info); return (ERROR_INVALID_DATA); } } (void) strlcpy(t->t_server, lfield[0], sizeof (t->t_server)); (void) strlcpy(t->t_share, lfield[1], sizeof (t->t_share)); t->t_state = strtoul(lfield[2], NULL, 10); t->t_priority.p_class = strtoul(lfield[3], NULL, 10); t->t_priority.p_rank = strtoul(lfield[4], NULL, 10); } return (ERROR_SUCCESS); } /* * Encodes given link information (info) */ static uint32_t dfs_link_encode(dfs_info_t *info, char *buf, size_t bufsz) { char linkdata[MAXREPARSELEN]; dfs_target_t *t; int i, sz; /* * Header format * ver:state:prop:timeout:guid:ntarget:cmntlen:comment */ sz = snprintf(buf, bufsz, "%u:%u:%u:%u:%s:%u:%u:%s", DFS_LINK_V1, info->i_state, info->i_propflags, info->i_timeout, info->i_guid, info->i_ntargets, strlen(info->i_comment), info->i_comment); if (sz > bufsz) { syslog(LOG_WARNING, "dfs: link data is too large"); dfs_info_trace("DFS link encode", info); return (ERROR_INTERNAL_ERROR); } /* * Format for each target * :server:share:state:class:rank */ bufsz -= sz; for (i = 0, t = info->i_targets; i < info->i_ntargets; i++, t++) { if (strchr(t->t_server, ':') || strchr(t->t_share, ':')) return (ERROR_INVALID_NAME); sz = snprintf(linkdata, MAXREPARSELEN, ":%s:%s:%u:%u:%u", t->t_server, t->t_share, t->t_state, t->t_priority.p_class, t->t_priority.p_rank); if (sz > bufsz) { syslog(LOG_WARNING, "dfs: link data is too large"); dfs_info_trace("DFS link encode", info); return (ERROR_INTERNAL_ERROR); } (void) strcat(buf, linkdata); bufsz -= sz; } return (ERROR_SUCCESS); } /* * Stores given information for the specified link */ static uint32_t dfs_link_commit(const char *path, dfs_info_t *info) { char linkdata[MAXREPARSELEN]; uint32_t status; int rc; status = dfs_link_encode(info, linkdata, MAXREPARSELEN); if (status == ERROR_SUCCESS) { rc = smb_reparse_svcadd(path, DFS_REPARSE_SVCTYPE, linkdata); if (rc != 0) status = ERROR_INTERNAL_ERROR; } return (status); } /* * Determines if the passed state is valid for a link */ static boolean_t dfs_link_isvalidstate(uint32_t state) { return (state == DFS_VOLUME_STATE_OK || state == DFS_VOLUME_STATE_OFFLINE || state == DFS_VOLUME_STATE_ONLINE); } /* * Initializes the given target structure (t) with provided information. */ static void dfs_target_init(dfs_target_t *t, const char *srv, const char *share, uint32_t state) { (void) strlcpy(t->t_server, (srv) ? srv : "", sizeof (t->t_server)); (void) strlcpy(t->t_share, (share) ? share : "", sizeof (t->t_share)); t->t_state = state; t->t_priority.p_class = DfsSiteCostNormalPriorityClass; t->t_priority.p_rank = 0; } /* * Lookup the specified target (server, share) in the given * target list (targets). If there is a match its index is * returned, otherwise -1 will be returned. */ static int dfs_target_find(dfs_target_t *targets, uint32_t ntargets, const char *server, const char *share) { dfs_target_t *t; int i; for (i = 0, t = targets; i < ntargets; i++, t++) { if ((smb_strcasecmp(t->t_server, server, 0) == 0) && (smb_strcasecmp(t->t_share, share, 0) == 0)) return (i); } return (-1); } /* * Determines if the passed state is valid for a link/root target */ static boolean_t dfs_target_isvalidstate(uint32_t state) { return (state == DFS_STORAGE_STATE_ONLINE || state == DFS_STORAGE_STATE_OFFLINE); } /* * Cache compare function, the key is UNC path */ static int dfs_cache_cmp(const void *p1, const void *p2) { smb_cache_node_t *cn1 = (smb_cache_node_t *)p1; smb_cache_node_t *cn2 = (smb_cache_node_t *)p2; dfs_nscnode_t *dn1 = cn1->cn_data; dfs_nscnode_t *dn2 = cn2->cn_data; int rc; rc = smb_strcasecmp(dn1->nsc_uncpath, dn2->nsc_uncpath, 0); if (rc < 0) return (-1); if (rc > 0) return (1); return (0); } /* * Adds an entry with given UNC and filesystem path and the specified * entry type (i.e. root/link) to the namespace cache. */ static uint32_t dfs_cache_add_byunc(const char *uncpath, const char *fspath, uint32_t type) { dfs_nscnode_t *dn; uint32_t status = ERROR_SUCCESS; if ((dn = malloc(sizeof (dfs_nscnode_t))) == NULL) return (ERROR_NOT_ENOUGH_MEMORY); (void) strlcpy(dn->nsc_uncpath, uncpath, sizeof (dn->nsc_uncpath)); (void) strlcpy(dn->nsc_fspath, fspath, sizeof (dn->nsc_fspath)); dn->nsc_type = type; if (smb_cache_add(&dfs_nscache, dn, SMB_CACHE_ADD) != 0) { free(dn); status = ERROR_INTERNAL_ERROR; } return (status); } /* * starting from DFS root directory, scans the tree for DFS links * and adds them to the cache. */ static void dfs_cache_populate(const char *unc_prefix, const char *dir) { char fspath[DFS_PATH_MAX]; char uncpath[DFS_PATH_MAX]; char *fname; int nentries, i; struct dirent **entry_list; uint32_t stat; nentries = scandir(dir, &entry_list, NULL, NULL); if (nentries == -1) return; for (i = 0; i < nentries; i++) { fname = entry_list[i]->d_name; if (strcmp(fname, ".") == 0 || strcmp(fname, "..") == 0) { free(entry_list[i]); continue; } (void) snprintf(fspath, DFS_PATH_MAX, "%s/%s", dir, fname); (void) snprintf(uncpath, DFS_PATH_MAX, "%s\\%s", unc_prefix, fname); if (dfs_path_isdir(fspath)) { dfs_cache_populate(uncpath, fspath); } else if (dfs_link_stat(fspath, &stat) == ERROR_SUCCESS) { if (stat == DFS_STAT_ISDFS) (void) dfs_cache_add_byunc(uncpath, fspath, DFS_OBJECT_LINK); } free(entry_list[i]); } for (; i < nentries; i++) free(entry_list[i]); free(entry_list); } /* * If this namespace hasn't been cached then return * without flushing the cache; otherwise clear the * name and flush the cache. */ static void dfs_cache_flush(const char *name) { (void) mutex_lock(&dfs_nsmtx); if (smb_strcasecmp(name, dfs_cached_ns, 0) != 0) { (void) mutex_unlock(&dfs_nsmtx); return; } *dfs_cached_ns = '\0'; (void) smb_config_setnum(SMB_CI_DFS_STDROOT_NUM, 0); (void) mutex_unlock(&dfs_nsmtx); smb_cache_flush(&dfs_nscache); } /* * Returns the number of cached namespaces */ static uint32_t dfs_cache_nscount(void) { uint32_t nscount; (void) mutex_lock(&dfs_nsmtx); nscount = (*dfs_cached_ns == '\0') ? 0 : 1; (void) mutex_unlock(&dfs_nsmtx); return (nscount); } /* * Determines whether the given path is a directory. */ static boolean_t dfs_path_isdir(const char *path) { struct stat statbuf; if (lstat(path, &statbuf) != 0) return (B_FALSE); return ((statbuf.st_mode & S_IFMT) == S_IFDIR); } /* * Validates the given state based on the object type (root/link), info * level, and whether it is the object's state or its target's state */ static uint32_t dfs_isvalidstate(uint32_t state, uint32_t type, boolean_t target, uint32_t infolvl) { uint32_t status = ERROR_SUCCESS; switch (infolvl) { case 101: if (type == DFS_OBJECT_ROOT) { if (!target) return (dfs_root_isvalidstate(state)); if (!dfs_target_isvalidstate(state)) status = ERROR_INVALID_PARAMETER; else if (state == DFS_STORAGE_STATE_OFFLINE) status = ERROR_NOT_SUPPORTED; } else { if (!target) { if (!dfs_link_isvalidstate(state)) status = ERROR_INVALID_PARAMETER; } else { if (!dfs_target_isvalidstate(state)) status = ERROR_INVALID_PARAMETER; } } break; case 105: if (state == 0) return (ERROR_SUCCESS); if (type == DFS_OBJECT_ROOT) { switch (state) { case DFS_VOLUME_STATE_OK: case DFS_VOLUME_STATE_OFFLINE: case DFS_VOLUME_STATE_ONLINE: case DFS_VOLUME_STATE_RESYNCHRONIZE: case DFS_VOLUME_STATE_STANDBY: status = ERROR_NOT_SUPPORTED; break; default: status = ERROR_INVALID_PARAMETER; } } else { switch (state) { case DFS_VOLUME_STATE_OK: case DFS_VOLUME_STATE_OFFLINE: case DFS_VOLUME_STATE_ONLINE: break; case DFS_VOLUME_STATE_RESYNCHRONIZE: case DFS_VOLUME_STATE_STANDBY: status = ERROR_NOT_SUPPORTED; break; default: status = ERROR_INVALID_PARAMETER; } } break; default: status = ERROR_INVALID_LEVEL; } return (status); } /* * Validates the given property flag mask based on the object * type (root/link) and namespace flavor. */ static uint32_t dfs_isvalidpropflagmask(uint32_t propflag_mask, uint32_t type, uint32_t flavor) { uint32_t flgs_not_supported; flgs_not_supported = DFS_PROPERTY_FLAG_ROOT_SCALABILITY | DFS_PROPERTY_FLAG_CLUSTER_ENABLED | DFS_PROPERTY_FLAG_ABDE; if (flavor == DFS_VOLUME_FLAVOR_STANDALONE) { if (type == DFS_OBJECT_LINK) flgs_not_supported |= DFS_PROPERTY_FLAG_SITE_COSTING; if (propflag_mask & flgs_not_supported) return (ERROR_NOT_SUPPORTED); } return (ERROR_SUCCESS); } /* * Based on the specified information level (infolvl) copy parts of the * information provided through newinfo into the existing information * (info) for the given object. */ static uint32_t dfs_modinfo(uint32_t type, dfs_info_t *info, dfs_info_t *newinfo, uint32_t infolvl) { boolean_t target_op = B_FALSE; uint32_t status = ERROR_SUCCESS; uint32_t state; int target_idx; if (newinfo->i_targets != NULL) { target_idx = dfs_target_find(info->i_targets, info->i_ntargets, newinfo->i_targets->t_server, newinfo->i_targets->t_share); if (target_idx == -1) return (ERROR_FILE_NOT_FOUND); target_op = B_TRUE; } switch (infolvl) { case 100: (void) strlcpy(info->i_comment, newinfo->i_comment, sizeof (newinfo->i_comment)); break; case 101: state = (target_op) ? newinfo->i_targets->t_state : newinfo->i_state; status = dfs_isvalidstate(state, type, target_op, 101); if (status != ERROR_SUCCESS) return (status); if (!target_op) { /* * states specified by this mask should not be stored */ if (state & DFS_VOLUME_STATES_SRV_OPS) return (ERROR_SUCCESS); info->i_state = state; } else { info->i_targets[target_idx].t_state = state; } break; case 102: info->i_timeout = newinfo->i_timeout; break; case 103: info->i_propflags = newinfo->i_propflags; break; case 104: info->i_targets[target_idx].t_priority = newinfo->i_targets->t_priority; break; case 105: status = dfs_isvalidstate(newinfo->i_state, type, B_FALSE, 105); if (status != ERROR_SUCCESS) return (status); status = dfs_isvalidpropflagmask(newinfo->i_propflag_mask, type, newinfo->i_flavor); if (status != ERROR_SUCCESS) return (status); (void) strlcpy(info->i_comment, newinfo->i_comment, sizeof (newinfo->i_comment)); if (newinfo->i_state != 0) info->i_state = newinfo->i_state; info->i_timeout = newinfo->i_timeout; info->i_propflags = newinfo->i_propflags; break; default: status = ERROR_INVALID_LEVEL; } return (status); }