mlsvc_winreg.c revision da6c28aaf62fa55f0fdb8004aa40f88f23bf53f0
/*
* 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
* 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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Windows Registry RPC (WINREG) server-side interface.
*
* The WINREG RPC interface returns Win32 error codes.
*
* HKLM Hive Key Local Machine
* HKU Hive Key Users
*/
#include <strings.h>
#include <smbsrv/ntstatus.h>
#include <smbsrv/mlsvc_util.h>
/*
* List of mlsvc handle (local handle management) keys.
*/
#define WINREG_HKLM "WinregOpenHKLM"
#define WINREG_HKU "WinregOpenUser"
#define WINREG_KEY "WinregOpenKey"
/*
* List of supported registry keys (case-insensitive).
* "System\\CurrentControlSet\\Services\\Alerter\\Parameters"
*/
static char *winreg_keys[] = {
"System\\CurrentControlSet\\Control\\ProductOptions",
"System\\CurrentControlSet\\Services\\Eventlog\\System"
};
static char *winreg_lookup_value(const char *);
static int winreg_s_OpenHKLM(void *, struct mlrpc_xaction *);
static int winreg_s_OpenHKUsers(void *, struct mlrpc_xaction *);
static int winreg_s_Close(void *, struct mlrpc_xaction *);
static int winreg_s_CreateKey(void *, struct mlrpc_xaction *);
static int winreg_s_DeleteKey(void *, struct mlrpc_xaction *);
static int winreg_s_DeleteValue(void *, struct mlrpc_xaction *);
static int winreg_s_OpenKey(void *, struct mlrpc_xaction *);
static int winreg_s_QueryKey(void *, struct mlrpc_xaction *);
static int winreg_s_QueryValue(void *, struct mlrpc_xaction *);
static int winreg_s_CreateValue(void *, struct mlrpc_xaction *);
static int winreg_s_Shutdown(void *, struct mlrpc_xaction *);
static int winreg_s_GetVersion(void *, struct mlrpc_xaction *);
static mlrpc_stub_table_t winreg_stub_table[] = {
{0}
};
static mlrpc_service_t winreg_service = {
"Winreg", /* name */
"Windows Registry", /* desc */
"\\winreg", /* endpoint */
PIPE_WINREG, /* sec_addr_port */
"338cd001-2244-31f1-aaaa900038001003", 1, /* abstract */
"8a885d04-1ceb-11c9-9fe808002b104860", 2, /* transfer */
0, /* no bind_instance_size */
0, /* no bind_req() */
0, /* no unbind_and_close() */
0, /* use generic_call_stub() */
winreg_stub_table /* stub_table */
};
static char winreg_sysname[SYS_NMLN];
/*
* winreg_initialize
*
* This function registers the WINREG RPC interface with the RPC runtime
* library. It must be called in order to use either the client side
* or the server side functions.
*/
void
winreg_initialize(void)
{
char *sysname;
sysname = "Solaris";
else
(void) mlrpc_register_service(&winreg_service);
}
/*
* winreg_s_OpenHKLM
*
* This is a request to open the HKLM and get a handle. The client
* should treat the handle as an opaque object.
*
* Status:
* ERROR_SUCCESS Valid handle returned.
* ERROR_ACCESS_DENIED Unable to allocate a handle.
*/
/*ARGSUSED*/
static int
{
} else {
}
return (MLRPC_DRC_OK);
}
/*
* winreg_s_OpenHKUsers
*
* This is a request to get a HKUsers handle. I'm not sure we are
* ready to fully support this interface yet, mostly due to the need
* to support subsequent requests, but we may support enough now. It
* seems okay with regedt32.
*/
/*ARGSUSED*/
static int
{
} else {
}
return (MLRPC_DRC_OK);
}
/*
* winreg_s_Close
*
* This is a request to close the WINREG interface specified by the
* handle. We don't track handles (yet), so just zero out the handle
* and return MLRPC_DRC_OK. Setting the handle to zero appears to be
* standard behaviour.
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}
/*
* winreg_s_CreateKey
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}
/*
* winreg_s_DeleteKey
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}
/*
* winreg_s_DeleteValue
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}
/*
* winreg_s_OpenKey
*
* This is a request to open a windows registry key. The list
* of supported keys is listed in the winreg_keys table. If we
* recognize the key, we return a handle.
*
* Returns:
* ERROR_SUCCESS Valid handle returned.
* ERROR_FILE_NOT_FOUND No key or unable to allocate a handle.
*/
/*ARGSUSED*/
static int
{
int i;
for (i = 0; i < sizeof (winreg_keys)/sizeof (winreg_keys[0]); ++i) {
WINREG_KEY, 0);
break;
sizeof (msreg_handle_t));
return (MLRPC_DRC_OK);
}
}
return (MLRPC_DRC_OK);
}
/*
* winreg_s_QueryKey
*/
/*ARGSUSED*/
static int
{
static char nullstr[2] = { 0, 0 };
return (MLRPC_DRC_OK);
}
/*
* winreg_s_QueryValue
*
* This is a request to get the value associated with a specified name.
*
* Returns:
* ERROR_SUCCESS Value returned.
* ERROR_FILE_NOT_FOUND PrimaryModule is not supported.
* ERROR_CANTREAD No such name or memory problem.
*/
static int
{
struct msreg_value *pv;
char *name;
char *value;
return (MLRPC_DRC_OK);
}
return (MLRPC_DRC_OK);
}
return (MLRPC_DRC_OK);
}
pv->vc_first_is = 0;
/*LINTED E_BAD_PTR_CAST_ALIGN*/
return (MLRPC_DRC_OK);
}
/*
* Lookup a name in the registry and return the associated value.
* Our registry is a case-insensitive, name-value pair table.
*
* Windows ProductType: WinNT, ServerNT, LanmanNT.
* Windows NT4.0 workstation: WinNT
* Windows NT4.0 server: ServerNT
*
* If LanmanNT is used here, Windows 2000 sends LsarQueryInfoPolicy
* with info level 6, which we don't support. If we use ServerNT
* (as reported by NT4.0 Server) Windows 2000 send requests for
* levels 3 and 5, which are support.
*
* On success, returns a pointer to the value. Otherwise returns
* a null pointer.
*/
static char *
winreg_lookup_value(const char *name)
{
static struct registry {
char *name;
char *value;
} registry[] = {
{ "ProductType", "ServerNT" },
};
int i;
return (winreg_sysname);
else
}
}
return (0);
}
/*
* winreg_s_CreateValue
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}
/*
* winreg_s_Shutdown
*
* Attempt to shutdown or reboot the system: access denied.
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}
/*
* winreg_s_GetVersion
*
* Return the windows registry version. The current version is 5.
* This call is usually made prior to enumerating or querying registry
* keys or values.
*/
/*ARGSUSED*/
static int
{
return (MLRPC_DRC_OK);
}