*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
/* Implementation of registry functions. */
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-static struct generic_mapping reg_generic_map =
+static const struct generic_mapping reg_generic_map =
{ REG_KEY_READ, REG_KEY_WRITE, REG_KEY_EXECUTE, REG_KEY_ALL };
/******************************************************************
- free() function for struct regkey_info
+ free() function for struct registry_key
*****************************************************************/
static void free_regkey(void *ptr)
WERROR result = WERR_OK;
struct registry_key *key;
- /* now do the internal open */
-
if (parent == NULL) {
result = reg_openhive(NULL, subkeyname, access_desired,
p->pipe_user.nt_user_token, &key);
return WERR_BADFILE;
}
- return WERR_OK;;
+ return WERR_OK;
}
/*******************************************************************
Note that P should be valid & hnd should already have space
*******************************************************************/
-static BOOL close_registry_key(pipes_struct *p, POLICY_HND *hnd)
+static bool close_registry_key(pipes_struct *p, POLICY_HND *hnd)
{
struct registry_key *regkey = find_regkey_by_hnd(p, hnd);
reg_close
********************************************************************/
-WERROR _winreg_CloseKey(pipes_struct *p, struct policy_handle *handle)
+WERROR _winreg_CloseKey(pipes_struct *p, struct winreg_CloseKey *r)
{
/* close the policy handle */
- if (!close_registry_key(p, handle))
+ if (!close_registry_key(p, r->in.handle))
return WERR_BADFID;
- ZERO_STRUCTP(handle);
+ ZERO_STRUCTP(r->out.handle);
return WERR_OK;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKLM(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKLM(pipes_struct *p, struct winreg_OpenHKLM *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKLM, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKLM, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKPD(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPD(pipes_struct *p, struct winreg_OpenHKPD *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKPD, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKPD, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKPT(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPT(pipes_struct *p, struct winreg_OpenHKPT *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKPT, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKPT, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKCR(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCR(pipes_struct *p, struct winreg_OpenHKCR *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKCR, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKCR, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKU(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKU(pipes_struct *p, struct winreg_OpenHKU *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKU, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKU, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKCU(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCU(pipes_struct *p, struct winreg_OpenHKCU *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKCU, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKCU, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKCC(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCC(pipes_struct *p, struct winreg_OpenHKCC *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKCC, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKCC, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKDD(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKDD(pipes_struct *p, struct winreg_OpenHKDD *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKDD, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKDD, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKPN(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPN(pipes_struct *p, struct winreg_OpenHKPN *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKPN, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKPN, r->in.access_mask);
}
/*******************************************************************
reg_reply_open_entry
********************************************************************/
-WERROR _winreg_OpenKey(pipes_struct *p, struct policy_handle *parent_handle,
- struct winreg_String keyname, uint32_t unknown,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenKey(pipes_struct *p, struct winreg_OpenKey *r)
{
- struct registry_key *parent = find_regkey_by_hnd(p, parent_handle );
+ struct registry_key *parent = find_regkey_by_hnd(p, r->in.parent_handle );
if ( !parent )
return WERR_BADFID;
- return open_registry_key(p, handle, parent, keyname.name, access_mask);
+ return open_registry_key(p, r->out.handle, parent, r->in.keyname.name, r->in.access_mask);
}
/*******************************************************************
reg_reply_info
********************************************************************/
-WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String value_name,
- enum winreg_Type *type, uint8_t *data,
- uint32_t *data_size, uint32_t *value_length)
+WERROR _winreg_QueryValue(pipes_struct *p, struct winreg_QueryValue *r)
{
WERROR status = WERR_BADFILE;
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
prs_struct prs_hkpd;
uint8_t *outbuf;
uint32_t outbuf_size;
DATA_BLOB val_blob;
- BOOL free_buf = False;
- BOOL free_prs = False;
+ bool free_buf = False;
+ bool free_prs = False;
if ( !regkey )
return WERR_BADFID;
- *value_length = *type = 0;
+ *r->out.value_length = *r->out.type = 0;
DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->key->name));
DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->key->type));
/* Handle QueryValue calls on HKEY_PERFORMANCE_DATA */
if(regkey->key->type == REG_KEY_HKPD)
{
- if(strequal(value_name.name, "Global")) {
- prs_init(&prs_hkpd, *data_size, p->mem_ctx, MARSHALL);
+ if(strequal(r->in.value_name.name, "Global")) {
+ prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
status = reg_perfcount_get_hkpd(
- &prs_hkpd, *data_size, &outbuf_size, NULL);
+ &prs_hkpd, *r->in.data_size, &outbuf_size, NULL);
outbuf = (uint8_t *)prs_hkpd.data_p;
free_prs = True;
}
- else if(strequal(value_name.name, "Counter 009")) {
+ else if(strequal(r->in.value_name.name, "Counter 009")) {
outbuf_size = reg_perfcount_get_counter_names(
reg_perfcount_get_base_index(),
(char **)(void *)&outbuf);
free_buf = True;
}
- else if(strequal(value_name.name, "Explain 009")) {
+ else if(strequal(r->in.value_name.name, "Explain 009")) {
outbuf_size = reg_perfcount_get_counter_help(
reg_perfcount_get_base_index(),
(char **)(void *)&outbuf);
free_buf = True;
}
- else if(isdigit(value_name.name[0])) {
+ else if(isdigit(r->in.value_name.name[0])) {
/* we probably have a request for a specific object
* here */
- prs_init(&prs_hkpd, *data_size, p->mem_ctx, MARSHALL);
+ prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
status = reg_perfcount_get_hkpd(
- &prs_hkpd, *data_size, &outbuf_size,
- value_name.name);
+ &prs_hkpd, *r->in.data_size, &outbuf_size,
+ r->in.value_name.name);
outbuf = (uint8_t *)prs_hkpd.data_p;
free_prs = True;
}
else {
DEBUG(3,("Unsupported key name [%s] for HKPD.\n",
- value_name.name));
+ r->in.value_name.name));
return WERR_BADFILE;
}
- *type = REG_BINARY;
+ *r->out.type = REG_BINARY;
}
else {
struct registry_value *val;
- status = reg_queryvalue(p->mem_ctx, regkey, value_name.name,
+ status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name.name,
&val);
if (!W_ERROR_IS_OK(status)) {
- if (data_size) {
- *data_size = 0;
+ if (r->out.data_size) {
+ *r->out.data_size = 0;
}
- if (value_length) {
- *value_length = 0;
+ if (r->out.value_length) {
+ *r->out.value_length = 0;
}
return status;
}
outbuf = val_blob.data;
outbuf_size = val_blob.length;
- *type = val->type;
+ *r->out.type = val->type;
}
- *value_length = outbuf_size;
+ *r->out.value_length = outbuf_size;
- if ( *data_size == 0 || !data ) {
+ if ( *r->in.data_size == 0 || !r->out.data ) {
status = WERR_OK;
- } else if ( *value_length > *data_size ) {
+ } else if ( *r->out.value_length > *r->in.data_size ) {
status = WERR_MORE_DATA;
} else {
- memcpy( data, outbuf, *value_length );
+ memcpy( r->out.data, outbuf, *r->out.value_length );
status = WERR_OK;
}
- *data_size = *value_length;
+ *r->out.data_size = *r->out.value_length;
if (free_prs) prs_mem_free(&prs_hkpd);
if (free_buf) SAFE_FREE(outbuf);
Implementation of REG_QUERY_KEY
****************************************************************************/
-WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String *classname,
- uint32_t *num_subkeys, uint32_t *max_subkeylen,
- uint32_t *max_subkeysize,
- uint32_t *num_values, uint32_t *max_valnamelen,
- uint32_t *max_valbufsize,
- uint32_t *secdescsize, NTTIME *last_changed_time)
+WERROR _winreg_QueryInfoKey(pipes_struct *p, struct winreg_QueryInfoKey *r)
{
WERROR status = WERR_OK;
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
if ( !regkey )
return WERR_BADFID;
- classname->name = NULL;
+ r->out.classname->name = NULL;
- status = reg_queryinfokey(regkey, num_subkeys, max_subkeylen,
- max_subkeysize, num_values, max_valnamelen,
- max_valbufsize, secdescsize,
- last_changed_time);
+ status = reg_queryinfokey(regkey, r->out.num_subkeys, r->out.max_subkeylen,
+ r->out.max_classlen, r->out.num_values, r->out.max_valnamelen,
+ r->out.max_valbufsize, r->out.secdescsize,
+ r->out.last_changed_time);
if (!W_ERROR_IS_OK(status)) {
return status;
}
* UTF-16. They are inexact at best, but so far they worked.
*/
- *max_subkeylen *= 2;
+ *r->out.max_subkeylen *= 2;
- *max_valnamelen += 1;
- *max_valnamelen *= 2;
+ *r->out.max_valnamelen += 1;
+ *r->out.max_valnamelen *= 2;
return WERR_OK;
}
Implementation of REG_GETVERSION
****************************************************************************/
-WERROR _winreg_GetVersion(pipes_struct *p, struct policy_handle *handle, uint32_t *version)
+WERROR _winreg_GetVersion(pipes_struct *p, struct winreg_GetVersion *r)
{
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
if ( !regkey )
return WERR_BADFID;
- *version = 0x00000005; /* Windows 2000 registry API version */
+ *r->out.version = 0x00000005; /* Windows 2000 registry API version */
return WERR_OK;
}
Implementation of REG_ENUM_KEY
****************************************************************************/
-WERROR _winreg_EnumKey(pipes_struct *p, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, struct winreg_StringBuf *keyclass, NTTIME *last_changed_time)
+WERROR _winreg_EnumKey(pipes_struct *p, struct winreg_EnumKey *r)
{
WERROR err;
- struct registry_key *key = find_regkey_by_hnd( p, handle );
+ struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
if ( !key )
return WERR_BADFID;
- if ( !name || !keyclass )
+ if ( !r->in.name || !r->in.keyclass )
return WERR_INVALID_PARAM;
DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", key->key->name));
- err = reg_enumkey(p->mem_ctx, key, enum_index, (char **)&name->name,
- last_changed_time);
+ err = reg_enumkey(p->mem_ctx, key, r->in.enum_index, (char **)&r->out.name->name,
+ r->out.last_changed_time);
if (!W_ERROR_IS_OK(err)) {
return err;
}
- keyclass->name = "";
+ r->out.keyclass->name = "";
return WERR_OK;
}
Implementation of REG_ENUM_VALUE
****************************************************************************/
-WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle,
- uint32_t enum_index, struct winreg_ValNameBuf *name,
- enum winreg_Type *type, uint8_t *data,
- uint32_t *data_size, uint32_t *value_length)
+WERROR _winreg_EnumValue(pipes_struct *p, struct winreg_EnumValue *r)
{
WERROR err;
- struct registry_key *key = find_regkey_by_hnd( p, handle );
+ struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
char *valname;
struct registry_value *val;
DATA_BLOB value_blob;
if ( !key )
return WERR_BADFID;
- if ( !name )
+ if ( !r->in.name )
return WERR_INVALID_PARAM;
DEBUG(8,("_winreg_EnumValue: enumerating values for key [%s]\n",
key->key->name));
- err = reg_enumvalue(p->mem_ctx, key, enum_index, &valname, &val);
+ err = reg_enumvalue(p->mem_ctx, key, r->in.enum_index, &valname, &val);
if (!W_ERROR_IS_OK(err)) {
return err;
}
return err;
}
- if (name != NULL) {
- name->name = valname;
+ if (r->out.name != NULL) {
+ r->out.name->name = valname;
}
- if (type != NULL) {
- *type = val->type;
+ if (r->out.type != NULL) {
+ *r->out.type = val->type;
}
- if (data != NULL) {
- if ((data_size == NULL) || (value_length == NULL)) {
+ if (r->out.value != NULL) {
+ if ((r->out.size == NULL) || (r->out.length == NULL)) {
return WERR_INVALID_PARAM;
}
- if (value_blob.length > *data_size) {
+ if (value_blob.length > *r->out.size) {
return WERR_MORE_DATA;
}
- memcpy( data, value_blob.data, value_blob.length );
+ memcpy( r->out.value, value_blob.data, value_blob.length );
}
- if (value_length != NULL) {
- *value_length = value_blob.length;
+ if (r->out.length != NULL) {
+ *r->out.length = value_blob.length;
}
- if (data_size != NULL) {
- *data_size = value_blob.length;
+ if (r->out.size != NULL) {
+ *r->out.size = value_blob.length;
}
return WERR_OK;
reg_shutdwon
********************************************************************/
-WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
+WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, struct winreg_InitiateSystemShutdown *r)
{
- uint32_t reason = 0;
+ struct winreg_InitiateSystemShutdownEx s;
+
+ s.in.hostname = r->in.hostname;
+ s.in.message = r->in.message;
+ s.in.timeout = r->in.timeout;
+ s.in.force_apps = r->in.force_apps;
+ s.in.reboot = r->in.reboot;
+ s.in.reason = 0;
/* thunk down to _winreg_InitiateSystemShutdownEx()
(just returns a status) */
- return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout,
- force_apps, reboot, reason );
+ return _winreg_InitiateSystemShutdownEx( p, &s );
}
/*******************************************************************
#define SHUTDOWN_F_STRING "-f"
-WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason)
+WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, struct winreg_InitiateSystemShutdownEx *r)
{
pstring shutdown_script;
char *msg = NULL;
pstring chkmsg;
fstring str_timeout;
fstring str_reason;
- fstring r;
+ fstring reboot;
fstring f;
int ret;
- BOOL can_shutdown;
+ bool can_shutdown;
pstrcpy(shutdown_script, lp_shutdown_script());
chkmsg[0] = '\0';
- if ( message && message->name && message->name->name ) {
- if ( (msg = talloc_strdup(p->mem_ctx, message->name->name )) == NULL ) {
+ if ( r->in.message && r->in.message->name && r->in.message->name->name ) {
+ if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->name->name )) == NULL ) {
return WERR_NOMEM;
}
alpha_strcpy (chkmsg, msg, NULL, sizeof(chkmsg));
}
- fstr_sprintf(str_timeout, "%d", timeout);
- fstr_sprintf(r, reboot ? SHUTDOWN_R_STRING : "");
- fstr_sprintf(f, force_apps ? SHUTDOWN_F_STRING : "");
- fstr_sprintf(str_reason, "%d", reason );
+ fstr_sprintf(str_timeout, "%d", r->in.timeout);
+ fstr_sprintf(reboot, r->in.reboot ? SHUTDOWN_R_STRING : "");
+ fstr_sprintf(f, r->in.force_apps ? SHUTDOWN_F_STRING : "");
+ fstr_sprintf(str_reason, "%d", r->in.reason );
all_string_sub( shutdown_script, "%z", chkmsg, sizeof(shutdown_script) );
all_string_sub( shutdown_script, "%t", str_timeout, sizeof(shutdown_script) );
- all_string_sub( shutdown_script, "%r", r, sizeof(shutdown_script) );
+ all_string_sub( shutdown_script, "%r", reboot, sizeof(shutdown_script) );
all_string_sub( shutdown_script, "%f", f, sizeof(shutdown_script) );
all_string_sub( shutdown_script, "%x", str_reason, sizeof(shutdown_script) );
reg_abort_shutdwon
********************************************************************/
-WERROR _winreg_AbortSystemShutdown(pipes_struct *p, uint16_t *server)
+WERROR _winreg_AbortSystemShutdown(pipes_struct *p, struct winreg_AbortSystemShutdown *r)
{
pstring abort_shutdown_script;
int ret;
- BOOL can_shutdown;
+ bool can_shutdown;
pstrcpy(abort_shutdown_script, lp_abort_shutdown_script());
if ( can_shutdown )
become_root();
-
+
ret = smbrun( abort_shutdown_script, NULL );
-
+
if ( can_shutdown )
unbecome_root();
-
+
/********** END SeRemoteShutdownPrivilege BLOCK **********/
DEBUG(3,("_reg_abort_shutdown: Running the command `%s' gave %d\n",
abort_shutdown_script, ret));
-
return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
}
int snum;
pstring share_path;
pstring unix_fname;
-
+
/* convert to a unix path, stripping the C:\ along the way */
-
- if ( !(p = valid_share_pathname( fname ) ))
+
+ if ( !(p = valid_share_pathname(NULL, fname)))
return -1;
/* has to exist within a valid file share */
-
+
for ( snum=0; snum<num_services; snum++ ) {
-
+
if ( !lp_snum_ok(snum) || lp_print_ok(snum) )
continue;
-
+
pstrcpy( share_path, lp_pathname(snum) );
/* make sure we have a path (e.g. [homes] ) */
if ( strncmp( share_path, p, strlen( share_path )) == 0 )
break;
}
-
+
/* p and fname are overlapping memory so copy out and back in again */
-
+
pstrcpy( unix_fname, p );
pstrcpy( fname, unix_fname );
-
+
+ TALLOC_FREE(p);
+
return (snum < num_services) ? snum : -1;
}
topkeypath ));
return WERR_BADFILE;
}
- pstrcpy( registry_key.name, topkeypath );
+
+ registry_key.name = talloc_strdup( regfile->mem_ctx, topkeypath );
+ if ( !registry_key.name ) {
+ DEBUG(0,("reg_load_tree: Talloc failed for reg_key.name!\n"));
+ return WERR_NOMEM;
+ }
/* now start parsing the values and subkeys */
/*******************************************************************
********************************************************************/
-WERROR _winreg_RestoreKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, uint32_t flags)
+WERROR _winreg_RestoreKey(pipes_struct *p, struct winreg_RestoreKey *r)
{
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
pstring fname;
int snum;
if ( !regkey )
return WERR_BADFID;
- if ( !filename || !filename->name )
+ if ( !r->in.filename || !r->in.filename->name )
return WERR_INVALID_PARAM;
- pstrcpy( fname, filename->name );
+ pstrcpy( fname, r->in.filename->name );
DEBUG(8,("_winreg_RestoreKey: verifying restore of key [%s] from "
"\"%s\"\n", regkey->key->name, fname));
/*******************************************************************
********************************************************************/
-WERROR _winreg_SaveKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, struct KeySecurityAttribute *sec_attrib)
+WERROR _winreg_SaveKey(pipes_struct *p, struct winreg_SaveKey *r)
{
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
pstring fname;
int snum;
if ( !regkey )
return WERR_BADFID;
- if ( !filename || !filename->name )
+ if ( !r->in.filename || !r->in.filename->name )
return WERR_INVALID_PARAM;
- pstrcpy( fname, filename->name );
+ pstrcpy( fname, r->in.filename->name );
DEBUG(8,("_winreg_SaveKey: verifying backup of key [%s] to \"%s\"\n",
regkey->key->name, fname));
/*******************************************************************
********************************************************************/
-WERROR _winreg_SaveKeyEx(pipes_struct *p)
+WERROR _winreg_SaveKeyEx(pipes_struct *p, struct winreg_SaveKeyEx *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_CreateKey( pipes_struct *p, struct policy_handle *handle,
- struct winreg_String keyname,
- struct winreg_String keyclass,
- uint32_t options, uint32_t access_mask,
- struct winreg_SecBuf *secdesc,
- struct policy_handle *new_handle,
- enum winreg_CreateAction *action_taken )
+WERROR _winreg_CreateKey( pipes_struct *p, struct winreg_CreateKey *r)
{
- struct registry_key *parent = find_regkey_by_hnd(p, handle);
+ struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
struct registry_key *new_key;
WERROR result;
if ( !parent )
return WERR_BADFID;
- result = reg_createkey(NULL, parent, keyname.name, access_mask,
- &new_key, action_taken);
+ result = reg_createkey(NULL, parent, r->in.name.name, r->in.access_mask,
+ &new_key, r->out.action_taken);
if (!W_ERROR_IS_OK(result)) {
return result;
}
- if (!create_policy_hnd(p, new_handle, free_regkey, new_key)) {
+ if (!create_policy_hnd(p, r->out.new_handle, free_regkey, new_key)) {
TALLOC_FREE(new_key);
return WERR_BADFILE;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_SetValue(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String name, enum winreg_Type type,
- uint8_t *data, uint32_t size)
+WERROR _winreg_SetValue(pipes_struct *p, struct winreg_SetValue *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
struct registry_value *val;
WERROR status;
if ( !key )
return WERR_BADFID;
- DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n", key->key->name,
- name.name));
+ DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n",
+ key->key->name, r->in.name.name));
- status = registry_pull_value(p->mem_ctx, &val, type, data, size, size);
+ status = registry_pull_value(p->mem_ctx, &val, r->in.type, r->in.data,
+ r->in.size, r->in.size);
if (!W_ERROR_IS_OK(status)) {
return status;
}
- return reg_setvalue(key, name.name, val);
+ return reg_setvalue(key, r->in.name.name, val);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_DeleteKey(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String key)
+WERROR _winreg_DeleteKey(pipes_struct *p, struct winreg_DeleteKey *r)
{
- struct registry_key *parent = find_regkey_by_hnd(p, handle);
+ struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
if ( !parent )
return WERR_BADFID;
- return reg_deletekey(parent, key.name);
+ return reg_deletekey(parent, r->in.key.name);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_DeleteValue(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String value)
+WERROR _winreg_DeleteValue(pipes_struct *p, struct winreg_DeleteValue *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
if ( !key )
return WERR_BADFID;
- return reg_deletevalue(key, value.name);
+ return reg_deletevalue(key, r->in.value.name);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle,
- uint32_t sec_info, struct KeySecurityData *sd)
+WERROR _winreg_GetKeySecurity(pipes_struct *p, struct winreg_GetKeySecurity *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
WERROR err;
struct security_descriptor *secdesc;
uint8 *data;
return err;
}
- if (len > sd->size) {
- sd->size = len;
+ if (len > r->out.sd->size) {
+ r->out.sd->size = len;
return WERR_INSUFFICIENT_BUFFER;
}
- sd->size = len;
- sd->len = len;
- sd->data = data;
+ r->out.sd->size = len;
+ r->out.sd->len = len;
+ r->out.sd->data = data;
return WERR_OK;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t access_mask, struct KeySecurityData *sd)
+WERROR _winreg_SetKeySecurity(pipes_struct *p, struct winreg_SetKeySecurity *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
struct security_descriptor *secdesc;
WERROR err;
if ( !(key->key->access_granted & STD_RIGHT_WRITE_DAC_ACCESS) )
return WERR_ACCESS_DENIED;
- err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, sd->data,
- sd->len, &secdesc));
+ err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, r->in.sd->data,
+ r->in.sd->len, &secdesc));
if (!W_ERROR_IS_OK(err)) {
return err;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_FlushKey(pipes_struct *p, struct policy_handle *handle)
+WERROR _winreg_FlushKey(pipes_struct *p, struct winreg_FlushKey *r)
{
/* I'm just replying OK because there's not a lot
here I see to do i --jerry */
/*******************************************************************
********************************************************************/
-WERROR _winreg_UnLoadKey(pipes_struct *p)
+WERROR _winreg_UnLoadKey(pipes_struct *p, struct winreg_UnLoadKey *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_ReplaceKey(pipes_struct *p)
+WERROR _winreg_ReplaceKey(pipes_struct *p, struct winreg_ReplaceKey *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_LoadKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename)
+WERROR _winreg_LoadKey(pipes_struct *p, struct winreg_LoadKey *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct policy_handle *handle, uint8_t watch_subtree, uint32_t notify_filter, uint32_t unknown, struct winreg_String string1, struct winreg_String string2, uint32_t unknown2)
+WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct winreg_NotifyChangeKeyValue *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct policy_handle *key_handle, struct QueryMultipleValue *values, uint32_t num_values, uint8_t *buffer, uint32_t *buffer_size)
+WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct winreg_QueryMultipleValues *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_QueryMultipleValues2(pipes_struct *p)
+WERROR _winreg_QueryMultipleValues2(pipes_struct *p, struct winreg_QueryMultipleValues2 *r)
{
/* fill in your code here if you think this call should
do anything */
git.samba.org / ira / wip.git / blobdiff