/*
* 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) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Net DFS server side RPC service for managing DFS namespaces.
*
* For more details refer to following Microsoft specification:
* [MS-DFSNM]
* Distributed File System (DFS): Namespace Management Protocol Specification
*/
#include <unistd.h>
#include <strings.h>
#include <sys/sysmacros.h>
#include <smbsrv/libntsvcs.h>
#include <smb/nmpipes.h>
#include <smbsrv/ndl/netdfs.ndl>
#include <dfs.h>
/*
* Depends on the information level requested around 4000 or more links
* can be provided with this buffer size. The limitation here is due
* to some problem in NDR and/or opipe layer so:
*
* - Do NOT increase the buffer size until that problem is fixed
* - The buffer size should be increased when the problem is fixed
* so the 4000 link limitation is removed.
*/
#define NETDFS_MAXBUFLEN (800 * 1024)
#define NETDFS_MAXPREFLEN ((uint32_t)(-1))
typedef struct netdfs_enumhandle_t {
uint32_t de_level; /* level of detail being requested */
uint32_t de_prefmaxlen; /* client MAX size buffer preference */
uint32_t de_resume; /* client resume handle */
uint32_t de_bavail; /* remaining buffer space in bytes */
uint32_t de_ntotal; /* total number of objects */
uint32_t de_nmax; /* MAX number of objects to return */
uint32_t de_nitems; /* number of objects in buf */
uint32_t de_nskip; /* number of objects to skip */
void *de_entries; /* ndr buffer */
} netdfs_enumhandle_t;
static int netdfs_s_getver(void *, ndr_xa_t *);
static int netdfs_s_add(void *, ndr_xa_t *);
static int netdfs_s_remove(void *, ndr_xa_t *);
static int netdfs_s_setinfo(void *, ndr_xa_t *);
static int netdfs_s_getinfo(void *, ndr_xa_t *);
static int netdfs_s_enum(void *, ndr_xa_t *);
static int netdfs_s_move(void *, ndr_xa_t *);
static int netdfs_s_rename(void *, ndr_xa_t *);
static int netdfs_s_addstdroot(void *, ndr_xa_t *);
static int netdfs_s_remstdroot(void *, ndr_xa_t *);
static int netdfs_s_enumex(void *, ndr_xa_t *);
static uint32_t netdfs_setinfo_100(dfs_path_t *, netdfs_info100_t *);
static uint32_t netdfs_setinfo_101(dfs_path_t *, netdfs_info101_t *,
const char *, const char *);
static uint32_t netdfs_setinfo_102(dfs_path_t *, netdfs_info102_t *);
static uint32_t netdfs_setinfo_103(dfs_path_t *, netdfs_info103_t *);
static uint32_t netdfs_setinfo_104(dfs_path_t *, netdfs_info104_t *,
const char *, const char *);
static uint32_t netdfs_setinfo_105(dfs_path_t *, netdfs_info105_t *);
static uint32_t netdfs_info_1(netdfs_info1_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_2(netdfs_info2_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_3(netdfs_info3_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_4(netdfs_info4_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_5(netdfs_info5_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_6(netdfs_info6_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_100(netdfs_info100_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_info_300(netdfs_info300_t *, dfs_info_t *, ndr_xa_t *,
uint32_t *);
static uint32_t netdfs_enum_common(netdfs_enumhandle_t *, ndr_xa_t *);
static boolean_t netdfs_guid_fromstr(char *, netdfs_uuid_t *);
static ndr_stub_table_t netdfs_stub_table[] = {
{ netdfs_s_getver, NETDFS_OPNUM_GETVER },
{ netdfs_s_add, NETDFS_OPNUM_ADD },
{ netdfs_s_remove, NETDFS_OPNUM_REMOVE },
{ netdfs_s_setinfo, NETDFS_OPNUM_SETINFO },
{ netdfs_s_getinfo, NETDFS_OPNUM_GETINFO },
{ netdfs_s_enum, NETDFS_OPNUM_ENUM },
{ netdfs_s_rename, NETDFS_OPNUM_RENAME },
{ netdfs_s_move, NETDFS_OPNUM_MOVE },
{ netdfs_s_addstdroot, NETDFS_OPNUM_ADDSTDROOT },
{ netdfs_s_remstdroot, NETDFS_OPNUM_REMSTDROOT },
{ netdfs_s_enumex, NETDFS_OPNUM_ENUMEX },
{0}
};
static ndr_service_t netdfs_service = {
"NETDFS", /* name */
"DFS", /* desc */
"\\netdfs", /* endpoint */
PIPE_NETDFS, /* sec_addr_port */
NETDFS_ABSTRACT_UUID, NETDFS_ABSTRACT_VERS,
NETDFS_TRANSFER_UUID, NETDFS_TRANSFER_VERS,
0, /* no bind_instance_size */
0, /* no bind_req() */
0, /* no unbind_and_close() */
0, /* use generic_call_stub() */
&TYPEINFO(netdfs_interface), /* interface ti */
netdfs_stub_table /* stub_table */
};
/*
* Register the NETDFS RPC interface with the RPC runtime library.
* The service must be registered in order to use either the client
* side or the server side functions.
*/
void
netdfs_initialize(void)
{
(void) ndr_svc_register(&netdfs_service);
dfs_init();
}
void
netdfs_finalize(void)
{
dfs_fini();
}
/*
* Returns the version number of the DFS server in use on the server.
*
* [MS-DFSNM]: NetrDfsManagerGetVersion (Opnum 0)
*/
/*ARGSUSED*/
static int
netdfs_s_getver(void *arg, ndr_xa_t *mxa)
{
struct netdfs_getver *param = arg;
param->version = DFS_MANAGER_VERSION_NT4;
return (NDR_DRC_OK);
}
/*
* Creates a new DFS link or adds a new target to an existing link of a
* DFS namespace.
*
* [MS-DFSNM]: NetrDfsAdd (Opnum 1)
*/
static int
netdfs_s_add(void *arg, ndr_xa_t *mxa)
{
netdfs_add_t *param = arg;
dfs_path_t path;
uint32_t status;
const char *uncpath = (const char *)param->dfs_path;
if (!ndr_is_admin(mxa)) {
param->status = ERROR_ACCESS_DENIED;
return (NDR_DRC_OK);
}
if (param->server == NULL || param->share == NULL) {
param->status = ERROR_INVALID_PARAMETER;
return (NDR_DRC_OK);
}
switch (param->flags) {
case DFS_CREATE_VOLUME:
case DFS_ADD_VOLUME:
case DFS_RESTORE_VOLUME:
case (DFS_ADD_VOLUME | DFS_RESTORE_VOLUME):
break;
default:
param->status = ERROR_INVALID_PARAMETER;
return (NDR_DRC_OK);
}
status = dfs_path_parse(&path, uncpath, DFS_OBJECT_LINK, SMB_NS_DFS);
if (status != ERROR_SUCCESS) {
param->status = status;
return (NDR_DRC_OK);
}
status = smb_name_validate_rpath(path.p_unc.unc_path);
if (status != ERROR_SUCCESS) {
dfs_path_free(&path);
param->status = status;
return (NDR_DRC_OK);
}
dfs_setpriv(PRIV_ON);
status = dfs_ns_addlink(path.p_unc.unc_share, &path,
(const char *)param->server, (const char *)param->share,
(const char *)param->comment, param->flags, SMB_NS_DFS);
dfs_setpriv(PRIV_OFF);
dfs_path_free(&path);
param->status = status;
return (NDR_DRC_OK);
}
/*
* 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.
*
* [MS-DFSNM]: NetrDfsRemove (Opnum 2)
*/
static int
netdfs_s_remove(void *arg, ndr_xa_t *mxa)
{
struct netdfs_remove *param = arg;
dfs_path_t path;
uint32_t status;
const char *uncpath = (const char *)param->dfs_path;
if (!ndr_is_admin(mxa)) {
param->status = ERROR_ACCESS_DENIED;
return (NDR_DRC_OK);
}
/* both server and share must be NULL or non-NULL */
if ((param->server == NULL && param->share != NULL) ||
(param->server != NULL && param->share == NULL)) {
param->status = ERROR_INVALID_PARAMETER;
return (NDR_DRC_OK);
}
status = dfs_path_parse(&path, uncpath, DFS_OBJECT_LINK, SMB_NS_DFS);
if (status != ERROR_SUCCESS) {
param->status = status;
return (NDR_DRC_OK);
}
dfs_setpriv(PRIV_ON);
status = dfs_ns_removelink(path.p_unc.unc_share, &path,
(const char *)param->server, (const char *)param->share,
SMB_NS_DFS);
dfs_setpriv(PRIV_OFF);
dfs_path_free(&path);
param->status = status;
return (NDR_DRC_OK);
}
/*
* Sets or modifies information relevant to a specific DFS root, DFS root
* target, DFS link, or DFS link target
*
* [MS-DFSNM]: NetrDfsSetInfo (Opnum 3)
*/
/*ARGSUSED*/
static int
netdfs_s_setinfo(void *arg, ndr_xa_t *mxa)
{
netdfs_setinfo_t *param = arg;
dfs_path_t path;
uint32_t status, stat;
/* both server and share must be NULL or non-NULL */
if ((param->server == NULL && param->share != NULL) ||
(param->server != NULL && param->share == NULL)) {
param->status = ERROR_INVALID_PARAMETER;
return (NDR_DRC_OK);
}
status = dfs_path_parse(&path, (const char *)param->dfs_path,
DFS_OBJECT_ANY, SMB_NS_DFS);
if (status != ERROR_SUCCESS) {
param->status = status;
return (NDR_DRC_OK);
}
dfs_setpriv(PRIV_ON);
if (path.p_type == DFS_OBJECT_LINK) {
status = dfs_link_stat((const char *)path.p_fspath, &stat);
if ((status != ERROR_SUCCESS) || (stat != DFS_STAT_ISDFS)) {
dfs_setpriv(PRIV_OFF);
dfs_path_free(&path);
param->status = ERROR_NOT_FOUND;
return (NDR_DRC_OK);
}
}
switch (param->info.level) {
case 100:
status = netdfs_setinfo_100(&path, param->info.iu.info100);
break;
case 101:
status = netdfs_setinfo_101(&path, param->info.iu.info101,
(const char *)param->server, (const char *)param->share);
break;
case 102:
status = netdfs_setinfo_102(&path, param->info.iu.info102);
break;
case 103:
status = netdfs_setinfo_103(&path, param->info.iu.info103);
break;
case 104:
status = netdfs_setinfo_104(&path, param->info.iu.info104,
(const char *)param->server, (const char *)param->share);
break;
case 105:
status = netdfs_setinfo_105(&path, param->info.iu.info105);
break;
default:
status = ERROR_INVALID_LEVEL;
break;
}
dfs_setpriv(PRIV_OFF);
dfs_path_free(&path);
param->status = status;
return (NDR_DRC_OK);
}
/*
* Returns information about a DFS root or a DFS link of the specified
* DFS namespace.
*
* [MS-DFSNM]: NetrDfsGetInfo (Opnum 4)
*/
static int
netdfs_s_getinfo(void *arg, ndr_xa_t *mxa)
{
netdfs_getinfo_t *param = arg;
netdfs_info1_t *info1;
netdfs_info2_t *info2;
netdfs_info3_t *info3;
netdfs_info4_t *info4;
netdfs_info5_t *info5;
netdfs_info6_t *info6;
netdfs_info100_t *info100;
dfs_info_t info;
dfs_path_t path;
uint32_t status, stat;
const char *fspath;
uint32_t level = param->level;
status = dfs_path_parse(&path, (const char *)param->dfs_path,
DFS_OBJECT_ANY, SMB_NS_DFS);
if (status != ERROR_SUCCESS)
goto getinfo_error;
dfs_setpriv(PRIV_ON);
fspath = path.p_fspath;
if (path.p_type == DFS_OBJECT_LINK) {
status = dfs_link_stat(fspath, &stat);
if ((status != ERROR_SUCCESS) || (stat != DFS_STAT_ISDFS)) {
status = ERROR_NOT_FOUND;
goto getinfo_error;
}
status = dfs_link_getinfo(fspath, &info, param->level,
SMB_NS_DFS);
} else {
status = dfs_root_getinfo(fspath, &info, param->level,
SMB_NS_DFS);
}
if (status != ERROR_SUCCESS)
goto getinfo_error;
(void) strlcpy(info.i_uncpath, (char *)param->dfs_path,
sizeof (info.i_uncpath));
dfs_info_trace("netdfs_s_getinfo", &info);
status = ERROR_NOT_ENOUGH_MEMORY;
switch (level) {
case 1:
if ((info1 = NDR_NEW(mxa, netdfs_info1_t)) != NULL) {
param->info.iu.info1 = info1;
status = netdfs_info_1(info1, &info, mxa, NULL);
}
break;
case 2:
if ((info2 = NDR_NEW(mxa, netdfs_info2_t)) != NULL) {
param->info.iu.info2 = info2;
status = netdfs_info_2(info2, &info, mxa, NULL);
}
break;
case 3:
if ((info3 = NDR_NEW(mxa, netdfs_info3_t)) != NULL) {
param->info.iu.info3 = info3;
status = netdfs_info_3(info3, &info, mxa, NULL);
}
break;
case 4:
if ((info4 = NDR_NEW(mxa, netdfs_info4_t)) != NULL) {
param->info.iu.info4 = info4;
status = netdfs_info_4(info4, &info, mxa, NULL);
}
break;
case 5:
if ((info5 = NDR_NEW(mxa, netdfs_info5_t)) != NULL) {
param->info.iu.info5 = info5;
status = netdfs_info_5(info5, &info, mxa, NULL);
}
break;
case 6:
if ((info6 = NDR_NEW(mxa, netdfs_info6_t)) != NULL) {
param->info.iu.info6 = info6;
status = netdfs_info_6(info6, &info, mxa, NULL);
}
break;
case 100:
if ((info100 = NDR_NEW(mxa, netdfs_info100_t)) != NULL) {
param->info.iu.info100 = info100;
status = netdfs_info_100(info100, &info, mxa, NULL);
}
break;
default:
status = ERROR_INVALID_LEVEL;
break;
}
dfs_info_free(&info);
getinfo_error:
dfs_setpriv(PRIV_OFF);
dfs_path_free(&path);
if (status != ERROR_SUCCESS)
bzero(param, sizeof (netdfs_getinfo_t));
param->info.level = level;
param->status = status;
return (NDR_DRC_OK);
}
/*
* Enumerates the DFS root hosted on a server or the DFS links of the
* namespace hosted by a server. Depending on the information level,
* the targets of the root and links are also displayed.
*
* For level 300, only one DFS root info is returned, no DFS links info.
* ERROR_DEVICE_NOT_AVAILABLE is returned if multiple namespaces are
* hosted by a server.
*
* For unsupported levels, it should return ERROR_INVALID_LEVEL as
* Microsoft does for DFS server on Win2000 and NT.
*
* [MS-DFSNM]: NetrDfsEnum (Opnum 5)
*/
/*ARGSUSED*/
static int
netdfs_s_enum(void *arg, ndr_xa_t *mxa)
{
netdfs_enum_t *param = arg;
netdfs_enumhandle_t de;
uint32_t level = param->level;
uint32_t status = ERROR_SUCCESS;
uint32_t nroot;
size_t entsize;
dfs_ns_hold(NULL);
if (param->info == NULL) {
status = ERROR_INVALID_PARAMETER;
goto enum_error;
}
if (!dfs_ns_exists(SMB_NS_DFS)) {
status = ERROR_NOT_FOUND;
goto enum_error;
}
if ((nroot = dfs_ns_count()) == 0)
status = ERROR_NOT_FOUND;
else if (nroot > 1)
status = ERROR_DEVICE_NOT_AVAILABLE;
if (status != ERROR_SUCCESS)
goto enum_error;
bzero(&de, sizeof (netdfs_enumhandle_t));
de.de_level = level;
de.de_ntotal = dfs_ns_numlink(NULL);
if (de.de_ntotal == 0) {
status = ERROR_NOT_FOUND;
goto enum_error;
}
if (param->pref_max_len == NETDFS_MAXPREFLEN ||
param->pref_max_len > NETDFS_MAXBUFLEN)
de.de_prefmaxlen = NETDFS_MAXBUFLEN;
else
de.de_prefmaxlen = param->pref_max_len;
de.de_bavail = de.de_prefmaxlen;
if (param->resume_handle != NULL) {
if (*param->resume_handle >= de.de_ntotal ||
(level == 300 && *param->resume_handle == 1)) {
status = ERROR_NO_MORE_ITEMS;
goto enum_error;
}
de.de_resume = *param->resume_handle;
de.de_nskip = de.de_resume;
*param->resume_handle = 0;
}
dfs_setpriv(PRIV_ON);
status = ERROR_NOT_ENOUGH_MEMORY;
switch (level) {
case 1:
entsize = sizeof (netdfs_info1_t);
de.de_nmax = MAX((de.de_prefmaxlen / entsize), 1);
de.de_entries = NDR_NEWN(mxa, netdfs_info1_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info1->info1 = de.de_entries;
param->info->iu.info1->count = de.de_nitems;
}
break;
case 2:
entsize = sizeof (netdfs_info2_t);
de.de_nmax = MAX((de.de_prefmaxlen / entsize), 1);
de.de_entries = NDR_NEWN(mxa, netdfs_info2_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info2->info2 = de.de_entries;
param->info->iu.info2->count = de.de_nitems;
}
break;
case 3:
entsize = sizeof (netdfs_info3_t) +
sizeof (netdfs_storage_info_t);
de.de_nmax = MAX((de.de_prefmaxlen / entsize), 1);
de.de_entries = NDR_NEWN(mxa, netdfs_info3_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info3->info3 = de.de_entries;
param->info->iu.info3->count = de.de_nitems;
}
break;
case 4:
entsize = sizeof (netdfs_info4_t) +
sizeof (netdfs_storage_info_t);
de.de_nmax = MAX((de.de_prefmaxlen / entsize), 1);
de.de_entries = NDR_NEWN(mxa, netdfs_info4_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info4->info4 = de.de_entries;
param->info->iu.info4->count = de.de_nitems;
}
break;
case 5:
entsize = sizeof (netdfs_info5_t);
de.de_nmax = MAX((de.de_prefmaxlen / entsize), 1);
de.de_entries = NDR_NEWN(mxa, netdfs_info5_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info5->info5 = de.de_entries;
param->info->iu.info5->count = de.de_nitems;
}
break;
case 6:
entsize = sizeof (netdfs_info6_t) +
sizeof (netdfs_storage_info1_t);
de.de_nmax = MAX((de.de_prefmaxlen / entsize), 1);
de.de_entries = NDR_NEWN(mxa, netdfs_info6_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info6->info6 = de.de_entries;
param->info->iu.info6->count = de.de_nitems;
}
break;
case 300:
entsize = sizeof (netdfs_info300_t);
de.de_nmax = 1;
de.de_entries = NDR_NEWN(mxa, netdfs_info300_t, de.de_nmax);
if (de.de_entries == NULL)
goto enum_error;
if ((status = netdfs_enum_common(&de, mxa)) == ERROR_SUCCESS) {
param->info->iu.info300->info300 = de.de_entries;
param->info->iu.info300->count = de.de_nitems;
}
break;
default:
status = ERROR_INVALID_PARAMETER;
break;
}
if ((status == ERROR_SUCCESS) && (param->resume_handle != NULL))
*param->resume_handle = de.de_resume;
enum_error:
dfs_ns_rele(NULL);
dfs_setpriv(PRIV_OFF);
param->status = status;
return (NDR_DRC_OK);
}
/*
* Renames or moves a DFS link
*
* Does not need to be supported for DFS version 1
*
* [MS-DFSNM]: NetrDfsMove (Opnum 6)
*/
/*ARGSUSED*/
static int
netdfs_s_move(void *arg, ndr_xa_t *mxa)
{
struct netdfs_move *param = arg;
param->status = ERROR_NOT_SUPPORTED;
return (NDR_DRC_OK);
}
/*
* According to [MS-DFSNM] spec this operation (opnum 7) is not
* used over the wire.
*/
/*ARGSUSED*/
static int
netdfs_s_rename(void *arg, ndr_xa_t *mxa)
{
struct netdfs_rename *param = arg;
param->status = ERROR_NOT_SUPPORTED;
return (NDR_DRC_OK);
}
/*
* Creates a new standalone DFS namespace
*
* [MS-DFSNM]: NetrDfsAddStdRoot (Opnum 12)
*/
/*ARGSUSED*/
static int
netdfs_s_addstdroot(void *arg, ndr_xa_t *mxa)
{
struct netdfs_addstdroot *param = arg;
const char *share = (const char *)param->share;
const char *comment = (const char *)param->comment;
if (!ndr_is_admin(mxa)) {
param->status = ERROR_ACCESS_DENIED;
return (NDR_DRC_OK);
}
dfs_setpriv(PRIV_ON);
param->status = dfs_ns_create(share, comment, SMB_NS_DFS);
dfs_setpriv(PRIV_OFF);
return (NDR_DRC_OK);
}
/*
* Deletes the specified stand-alone DFS namespace. The DFS namespace can be
* removed without first removing all of the links in it.
*
* [MS-DFSNM]: NetrDfsRemoveStdRoot (Opnum 13)
*/
/*ARGSUSED*/
static int
netdfs_s_remstdroot(void *arg, ndr_xa_t *mxa)
{
struct netdfs_remstdroot *param = arg;
const char *share = (const char *)param->share;
dfs_setpriv(PRIV_ON);
if (ndr_is_admin(mxa))
param->status = dfs_ns_destroy(share, SMB_NS_DFS);
else
param->status = ERROR_ACCESS_DENIED;
dfs_setpriv(PRIV_OFF);
return (NDR_DRC_OK);
}
/*
* Enumerates the DFS roots hosted on a server, or DFS links of a namespace
* hosted by the server. Depending on the information level, the targets
* associated with the roots and links are also displayed
*
* Does not need to be supported for DFS version 1
*
* [MS-DFSNM] NetrDfsEnumEx (Opnum 21)
*/
/*ARGSUSED*/
static int
netdfs_s_enumex(void *arg, ndr_xa_t *mxa)
{
struct netdfs_enumex *param = arg;
bzero(param->info, sizeof (struct netdfs_enumex));
param->status = ERROR_NOT_SUPPORTED;
return (NDR_DRC_OK);
}
/*
* Sets the comment for the DFS link/root.
*/
static uint32_t
netdfs_setinfo_100(dfs_path_t *path, netdfs_info100_t *netinfo)
{
dfs_info_t info;
uint32_t status;
char *cmnt = (char *)netinfo->comment;
bzero(&info, sizeof (dfs_info_t));
if (cmnt != NULL)
(void) strlcpy(info.i_comment, cmnt, sizeof (info.i_comment));
if (path->p_type == DFS_OBJECT_LINK)
status = dfs_link_setinfo(path->p_fspath, &info, 100,
SMB_NS_DFS);
else
status = dfs_root_setinfo(path->p_fspath, &info, 100,
SMB_NS_DFS);
return (status);
}
/*
* Sets the state for the DFS root/link or its target.
*/
static uint32_t
netdfs_setinfo_101(dfs_path_t *path, netdfs_info101_t *netinfo,
const char *t_server, const char *t_share)
{
dfs_info_t info;
dfs_target_t target;
uint32_t status;
bzero(&info, sizeof (dfs_info_t));
bzero(&target, sizeof (dfs_target_t));
if (t_server == NULL && t_share == NULL) {
info.i_state = netinfo->state;
} else {
target.t_state = netinfo->state;
(void) strlcpy(target.t_server, t_server,
sizeof (target.t_server));
(void) strlcpy(target.t_share, t_share,
sizeof (target.t_share));
info.i_targets = &target;
}
if (path->p_type == DFS_OBJECT_LINK)
status = dfs_link_setinfo(path->p_fspath, &info, 101,
SMB_NS_DFS);
else
status = dfs_root_setinfo(path->p_fspath, &info, 101,
SMB_NS_DFS);
return (status);
}
/*
* Sets the timeout value of the DFS link/root.
*/
static uint32_t
netdfs_setinfo_102(dfs_path_t *path, netdfs_info102_t *netinfo)
{
dfs_info_t info;
uint32_t status;
bzero(&info, sizeof (dfs_info_t));
info.i_timeout = netinfo->timeout;
if (path->p_type == DFS_OBJECT_LINK)
status = dfs_link_setinfo(path->p_fspath, &info, 102,
SMB_NS_DFS);
else
status = dfs_root_setinfo(path->p_fspath, &info, 102,
SMB_NS_DFS);
return (status);
}
/*
* Sets the property flags for the root or link.
*/
static uint32_t
netdfs_setinfo_103(dfs_path_t *path, netdfs_info103_t *netinfo)
{
dfs_info_t info;
uint32_t status;
bzero(&info, sizeof (dfs_info_t));
info.i_propflags =
netinfo->property_flags & netinfo->property_flag_mask;
if (path->p_type == DFS_OBJECT_LINK)
status = dfs_link_setinfo(path->p_fspath, &info, 103,
SMB_NS_DFS);
else
status = dfs_root_setinfo(path->p_fspath, &info, 103,
SMB_NS_DFS);
return (status);
}
/*
* Sets the target priority rank and class for the root target or link target
*/
static uint32_t
netdfs_setinfo_104(dfs_path_t *path, netdfs_info104_t *netinfo,
const char *t_server, const char *t_share)
{
dfs_info_t info;
dfs_target_t target;
uint32_t status;
if ((t_server == NULL) || (t_share == NULL))
return (ERROR_INVALID_PARAMETER);
if (netinfo->priority_class > DfsGlobalLowPriorityClass)
return (ERROR_INVALID_PARAMETER);
if (netinfo->priority_rank > DFS_PRIORITY_RANK_MAX)
return (ERROR_INVALID_PARAMETER);
bzero(&info, sizeof (dfs_info_t));
bzero(&target, sizeof (dfs_target_t));
target.t_priority.p_class = netinfo->priority_class;
target.t_priority.p_rank = netinfo->priority_rank;
(void) strlcpy(target.t_server, t_server, sizeof (target.t_server));
(void) strlcpy(target.t_share, t_share, sizeof (target.t_share));
info.i_targets = &target;
if (path->p_type == DFS_OBJECT_LINK)
status = dfs_link_setinfo(path->p_fspath, &info, 104,
SMB_NS_DFS);
else
status = dfs_root_setinfo(path->p_fspath, &info, 104,
SMB_NS_DFS);
return (status);
}
/*
* Sets the comment, state, time-out information, and property flags for the
* namespace root or link specified in DfsInfo. Does not apply to a root target
* or link target.
*/
static uint32_t
netdfs_setinfo_105(dfs_path_t *path, netdfs_info105_t *netinfo)
{
dfs_info_t info;
uint32_t status, flavor;
char *cmnt = (char *)netinfo->comment;
bzero(&info, sizeof (dfs_info_t));
flavor = dfs_ns_getflavor(path->p_unc.unc_share, SMB_NS_DFS);
if (flavor == 0)
return (ERROR_INTERNAL_ERROR);
info.i_flavor = flavor;
if (cmnt != NULL)
(void) strlcpy(info.i_comment, cmnt, sizeof (info.i_comment));
info.i_state = netinfo->state;
info.i_timeout = netinfo->timeout;
info.i_propflag_mask = netinfo->property_flag_mask;
info.i_propflags =
netinfo->property_flags & netinfo->property_flag_mask;
if (path->p_type == DFS_OBJECT_LINK)
status = dfs_link_setinfo(path->p_fspath, &info, 105,
SMB_NS_DFS);
else
status = dfs_root_setinfo(path->p_fspath, &info, 105,
SMB_NS_DFS);
return (status);
}
/*
* DFS_STORAGE_INFO: target information
*/
static uint32_t
netdfs_info_storage(netdfs_storage_info_t **sinfo, dfs_info_t *info,
ndr_xa_t *mxa, uint32_t *size)
{
netdfs_storage_info_t *storage;
dfs_target_t *target;
int i;
*sinfo = NULL;
if (info->i_ntargets == 0)
return (ERROR_SUCCESS);
*sinfo = NDR_NEWN(mxa, netdfs_storage_info_t, info->i_ntargets);
if (*sinfo == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (size != NULL)
*size += info->i_ntargets * sizeof (netdfs_storage_info_t);
target = info->i_targets;
storage = *sinfo;
for (i = 0; i < info->i_ntargets; i++, target++, storage++) {
storage->state = target->t_state;
storage->server = NDR_STRDUP(mxa, target->t_server);
storage->share = NDR_STRDUP(mxa, target->t_share);
if (storage->server == NULL || storage->share == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (size != NULL)
*size += smb_wcequiv_strlen(target->t_server) +
smb_wcequiv_strlen(target->t_share);
}
return (ERROR_SUCCESS);
}
/*
* DFS_STORAGE_INFO_1: target information
*/
static uint32_t
netdfs_info_storage1(netdfs_storage_info1_t **sinfo, dfs_info_t *info,
ndr_xa_t *mxa, uint32_t *size)
{
netdfs_storage_info1_t *storage;
dfs_target_t *target;
int i;
*sinfo = NULL;
if (info->i_ntargets == 0)
return (ERROR_SUCCESS);
*sinfo = NDR_NEWN(mxa, netdfs_storage_info1_t, info->i_ntargets);
if (*sinfo == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (size != NULL)
*size += info->i_ntargets * sizeof (netdfs_storage_info1_t);
target = info->i_targets;
storage = *sinfo;
for (i = 0; i < info->i_ntargets; i++, target++, storage++) {
storage->state = target->t_state;
storage->server = NDR_STRDUP(mxa, target->t_server);
storage->share = NDR_STRDUP(mxa, target->t_share);
storage->p_class = target->t_priority.p_class;
storage->p_rank = target->t_priority.p_rank;
storage->p_reserved = 0;
if (storage->server == NULL || storage->share == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (size != NULL)
*size += smb_wcequiv_strlen(target->t_server) +
smb_wcequiv_strlen(target->t_share);
}
return (ERROR_SUCCESS);
}
/*
* Sets a DFS_INFO_1 for get/enum response
*/
static uint32_t
netdfs_info_1(netdfs_info1_t *info1, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
info1->entry_path = NDR_STRDUP(mxa, info->i_uncpath);
if (info1->entry_path == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (size != NULL)
*size = sizeof (netdfs_info1_t) +
smb_wcequiv_strlen(info->i_uncpath);
return (ERROR_SUCCESS);
}
/*
* Sets a DFS_INFO_2 for get/enum response
*/
static uint32_t
netdfs_info_2(netdfs_info2_t *info2, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
void *entry_path;
void *comment;
entry_path = NDR_STRDUP(mxa, info->i_uncpath);
comment = NDR_STRDUP(mxa, info->i_comment);
if (entry_path == NULL || comment == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
info2->entry_path = entry_path;
info2->comment = comment;
info2->state = info->i_state;
info2->n_store = info->i_ntargets;
if (size != NULL)
*size = sizeof (netdfs_info2_t) +
smb_wcequiv_strlen(info->i_uncpath) +
smb_wcequiv_strlen(info->i_comment);
return (ERROR_SUCCESS);
}
/*
* Sets a DFS_INFO_3 for get/enum response
*/
static uint32_t
netdfs_info_3(netdfs_info3_t *info3, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
void *entry_path;
void *comment;
entry_path = NDR_STRDUP(mxa, info->i_uncpath);
comment = NDR_STRDUP(mxa, info->i_comment);
if (entry_path == NULL || comment == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
info3->entry_path = entry_path;
info3->comment = comment;
info3->state = info->i_state;
info3->n_store = info->i_ntargets;
if (size != NULL)
*size = sizeof (netdfs_info3_t) +
smb_wcequiv_strlen(info->i_uncpath) +
smb_wcequiv_strlen(info->i_comment);
return (netdfs_info_storage(&info3->si, info, mxa, size));
}
/*
* Sets a DFS_INFO_4 for get/enum response
*/
static uint32_t
netdfs_info_4(netdfs_info4_t *info4, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
void *entry_path;
void *comment;
entry_path = NDR_STRDUP(mxa, info->i_uncpath);
comment = NDR_STRDUP(mxa, info->i_comment);
if (entry_path == NULL || comment == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (!netdfs_guid_fromstr(info->i_guid, &info4->guid))
return (ERROR_INVALID_DATA);
info4->entry_path = entry_path;
info4->comment = comment;
info4->state = info->i_state;
info4->timeout = info->i_timeout;
info4->n_store = info->i_ntargets;
if (size != NULL)
*size = sizeof (netdfs_info4_t) +
smb_wcequiv_strlen(info->i_uncpath) +
smb_wcequiv_strlen(info->i_comment);
return (netdfs_info_storage(&info4->si, info, mxa, size));
}
/*
* Sets a DFS_INFO_5 for get/enum response
*/
static uint32_t
netdfs_info_5(netdfs_info5_t *info5, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
void *entry_path;
void *comment;
entry_path = NDR_STRDUP(mxa, info->i_uncpath);
comment = NDR_STRDUP(mxa, info->i_comment);
if (entry_path == NULL || comment == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (!netdfs_guid_fromstr(info->i_guid, &info5->guid))
return (ERROR_INVALID_DATA);
info5->entry_path = entry_path;
info5->comment = comment;
info5->state = info->i_state;
info5->timeout = info->i_timeout;
info5->flags = info->i_propflags;
info5->metadata_sz = 0;
info5->n_store = info->i_ntargets;
if (size != NULL)
*size = sizeof (netdfs_info5_t) +
smb_wcequiv_strlen(info->i_uncpath) +
smb_wcequiv_strlen(info->i_comment);
return (ERROR_SUCCESS);
}
/*
* Sets a DFS_INFO_6 for get/enum response
*/
static uint32_t
netdfs_info_6(netdfs_info6_t *info6, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
void *entry_path;
void *comment;
entry_path = NDR_STRDUP(mxa, info->i_uncpath);
comment = NDR_STRDUP(mxa, info->i_comment);
if (entry_path == NULL || comment == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (!netdfs_guid_fromstr(info->i_guid, &info6->guid))
return (ERROR_INVALID_DATA);
info6->entry_path = entry_path;
info6->comment = comment;
info6->state = info->i_state;
info6->timeout = info->i_timeout;
info6->flags = info->i_propflags;
info6->metadata_sz = 0;
info6->n_store = info->i_ntargets;
if (size != NULL)
*size = sizeof (netdfs_info6_t) +
smb_wcequiv_strlen(info->i_uncpath) +
smb_wcequiv_strlen(info->i_comment);
return (netdfs_info_storage1(&info6->si, info, mxa, size));
}
/*
* Sets a DFS_INFO_100 for Get response
*/
static uint32_t
netdfs_info_100(netdfs_info100_t *info100, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
info100->comment = NDR_STRDUP(mxa, info->i_comment);
if (info100->comment == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
if (size != NULL)
*size = sizeof (netdfs_info100_t) +
smb_wcequiv_strlen(info->i_comment);
return (ERROR_SUCCESS);
}
/*
* Sets a DFS_INFO_300 for Enum response
*/
static uint32_t
netdfs_info_300(netdfs_info300_t *info300, dfs_info_t *info, ndr_xa_t *mxa,
uint32_t *size)
{
info300->dfsname = NDR_STRDUP(mxa, info->i_uncpath);
if (info300->dfsname == NULL)
return (ERROR_NOT_ENOUGH_MEMORY);
info300->flavor = DFS_VOLUME_FLAVOR_STANDALONE;
if (size != NULL)
*size = sizeof (netdfs_info300_t) +
smb_wcequiv_strlen(info->i_uncpath);
return (ERROR_SUCCESS);
}
/*
* Common enumeration function.
* Caller must be holding namespace lock (dfs_ns_hold)
*/
static uint32_t
netdfs_enum_common(netdfs_enumhandle_t *de, ndr_xa_t *mxa)
{
netdfs_info1_t *info1 = de->de_entries;
netdfs_info2_t *info2 = de->de_entries;
netdfs_info3_t *info3 = de->de_entries;
netdfs_info4_t *info4 = de->de_entries;
netdfs_info5_t *info5 = de->de_entries;
netdfs_info6_t *info6 = de->de_entries;
netdfs_info300_t *info300 = de->de_entries;
dfs_info_t dfsinfo;
dfs_node_t *dn;
uint32_t status;
uint32_t itemsz;
de->de_nitems = 0;
if ((dn = dfs_ns_firstlink(NULL)) == NULL)
return (ERROR_SUCCESS);
do {
if (de->de_level == 300 && dn->dn_type != DFS_OBJECT_ROOT)
continue;
if (de->de_nskip > 0) {
de->de_nskip--;
continue;
}
if (de->de_nitems == de->de_nmax)
break;
status = dfs_getinfo(dn, &dfsinfo, de->de_level, SMB_NS_DFS);
if (status != ERROR_SUCCESS)
continue;
switch (de->de_level) {
case 1:
status = netdfs_info_1(info1, &dfsinfo, mxa, &itemsz);
info1++;
break;
case 2:
status = netdfs_info_2(info2, &dfsinfo, mxa, &itemsz);
info2++;
break;
case 3:
status = netdfs_info_3(info3, &dfsinfo, mxa, &itemsz);
info3++;
break;
case 4:
status = netdfs_info_4(info4, &dfsinfo, mxa, &itemsz);
info4++;
break;
case 5:
status = netdfs_info_5(info5, &dfsinfo, mxa, &itemsz);
info5++;
break;
case 6:
status = netdfs_info_6(info6, &dfsinfo, mxa, &itemsz);
info6++;
break;
case 300:
status = netdfs_info_300(info300, &dfsinfo, mxa,
&itemsz);
info300++;
break;
default:
status = ERROR_INVALID_LEVEL;
}
dfs_info_free(&dfsinfo);
if (status != ERROR_SUCCESS)
return (status);
if (de->de_nmax == 1) {
de->de_nitems = 1;
break;
}
if (itemsz > de->de_bavail)
break;
de->de_bavail -= itemsz;
de->de_nitems++;
} while ((dn = dfs_ns_nextlink(NULL, dn)) != NULL);
de->de_resume += de->de_nitems;
return (ERROR_SUCCESS);
}
/*
* Converts the guid string into binary format in network byte order.
*/
static boolean_t
netdfs_guid_fromstr(char *guid_str, netdfs_uuid_t *guid)
{
uuid_t uuid;
if (uuid_parse(guid_str, uuid) != 0)
return (B_FALSE);
bcopy(&uuid, guid, sizeof (uuid_t));
guid->data1 = htonl(guid->data1);
guid->data2 = htons(guid->data2);
guid->data3 = htons(guid->data3);
return (B_TRUE);
}