BIG merge from trunk. Features not copied over

[metze/old/v3-2-winbind-ndr.git] / source / rpc_parse / parse_reg.c

diff --git a/source/rpc_parse/parse_reg.c b/source/rpc_parse/parse_reg.c
index 7e8ae030397961d02bdbb3d5f467126197c9cdcd..295fead103566195d23948c4c840c97d6b3bf191 100644 (file)
--- a/source/rpc_parse/parse_reg.c
+++ b/source/rpc_parse/parse_reg.c
@@ -33,7 +33,7 @@
  Fill in a REGVAL_BUFFER for the data given a REGISTRY_VALUE
  *******************************************************************/
 
-static uint32 reg_init_regval_buffer( REGVAL_BUFFER *buf2, REGISTRY_VALUE *val )
+uint32 reg_init_regval_buffer( REGVAL_BUFFER *buf2, REGISTRY_VALUE *val )
 {
        uint32          real_size = 0;
        
@@ -206,17 +206,17 @@ static BOOL reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec,
  Inits a registry key create request
 ********************************************************************/
 
-void init_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
-                           char *name, char *class, uint32 access_desired,
+void init_reg_q_create_key_ex(REG_Q_CREATE_KEY_EX *q_c, POLICY_HND *hnd,
+                           char *name, char *key_class, uint32 access_desired,
                            SEC_DESC_BUF *sec_buf)
 {
        ZERO_STRUCTP(q_c);
 
-       memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
+       memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
 
 
        init_unistr4( &q_c->name, name, UNI_STR_TERMINATE );
-       init_unistr4( &q_c->class, class, UNI_STR_TERMINATE );
+       init_unistr4( &q_c->key_class, key_class, UNI_STR_TERMINATE );
 
        q_c->access = access_desired;
 
@@ -227,26 +227,26 @@ void init_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
        q_c->ptr2 = 1;
        init_buf_hdr(&q_c->hdr_sec, sec_buf->len, sec_buf->len);
        q_c->ptr3 = 1;
-       q_c->unknown_2 = 0x00000000;
+       q_c->disposition = TALLOC_P( get_talloc_ctx(), uint32 );
 }
 
 /*******************************************************************
 Marshalls a registry key create request
 ********************************************************************/
 
-BOOL reg_io_q_create_key(const char *desc,  REG_Q_CREATE_KEY *q_u,
+BOOL reg_io_q_create_key_ex(const char *desc,  REG_Q_CREATE_KEY_EX *q_u,
                          prs_struct *ps, int depth)
 {
        if ( !q_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_q_create_key");
+       prs_debug(ps, depth, desc, "reg_io_q_create_key_ex");
        depth++;
 
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &q_u->pnt_pol, ps, depth))
+       if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
                return False;
 
        if(!prs_unistr4 ("name", ps, depth, &q_u->name))
@@ -254,12 +254,12 @@ BOOL reg_io_q_create_key(const char *desc,  REG_Q_CREATE_KEY *q_u,
        if(!prs_align(ps))
                return False;
 
-       if(!prs_unistr4 ("class", ps, depth, &q_u->class))
+       if(!prs_unistr4 ("key_class", ps, depth, &q_u->key_class))
                return False;
        if(!prs_align(ps))
                return False;
 
-       if(!prs_uint32("reserved", ps, depth, &q_u->reserved))
+       if(!prs_uint32("options", ps, depth, &q_u->options))
                return False;
        if(!prs_uint32("access", ps, depth, &q_u->access))
                return False;
@@ -267,16 +267,15 @@ BOOL reg_io_q_create_key(const char *desc,  REG_Q_CREATE_KEY *q_u,
        if(!prs_pointer("sec_info", ps, depth, (void**)&q_u->sec_info, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
                return False;
 
-       if(!prs_uint32("ptr2", ps, depth, &q_u->ptr2))
-               return False;
-       if(!reg_io_hdrbuf_sec(q_u->ptr2, &q_u->ptr3, &q_u->hdr_sec, q_u->data,
-                             ps, depth))
-               return False;
+       if ( q_u->sec_info ) {
+               if(!prs_uint32("ptr2", ps, depth, &q_u->ptr2))
+                       return False;
+               if(!reg_io_hdrbuf_sec(q_u->ptr2, &q_u->ptr3, &q_u->hdr_sec, q_u->data, ps, depth))
+                       return False;
+       }
 
-#if 0
-       if(!prs_uint32("unknown_2", ps, depth, &q_u->unknown_2))
+       if(!prs_pointer("disposition", ps, depth, (void**)&q_u->disposition, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
                return False;
-#endif
 
        return True;
 }
@@ -285,21 +284,21 @@ BOOL reg_io_q_create_key(const char *desc,  REG_Q_CREATE_KEY *q_u,
 Unmarshalls a registry key create response
 ********************************************************************/
 
-BOOL reg_io_r_create_key(const char *desc,  REG_R_CREATE_KEY *r_u,
+BOOL reg_io_r_create_key_ex(const char *desc,  REG_R_CREATE_KEY_EX *r_u,
                          prs_struct *ps, int depth)
 {
        if ( !r_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_r_create_key");
+       prs_debug(ps, depth, desc, "reg_io_r_create_key_ex");
        depth++;
 
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &r_u->key_pol, ps, depth))
+       if(!smb_io_pol_hnd("", &r_u->handle, ps, depth))
                return False;
-       if(!prs_uint32("unknown", ps, depth, &r_u->unknown))
+       if(!prs_uint32("disposition", ps, depth, &r_u->disposition))
                return False;
 
        if(!prs_werror("status", ps, depth, &r_u->status))
@@ -318,7 +317,7 @@ void init_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
 {
        ZERO_STRUCTP(q_c);
 
-       memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
+       memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
        init_unistr4(&q_c->name, name, UNI_STR_TERMINATE);
 }
 
@@ -326,25 +325,23 @@ void init_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
 reads or writes a structure.
 ********************************************************************/
 
-BOOL reg_io_q_delete_val(const char *desc, REG_Q_DELETE_VALUE *q_u,
+BOOL reg_io_q_delete_value(const char *desc, REG_Q_DELETE_VALUE *q_u,
                          prs_struct *ps, int depth)
 {
        if ( !q_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_q_delete_val");
+       prs_debug(ps, depth, desc, "reg_io_q_delete_value");
        depth++;
 
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &q_u->pnt_pol, ps, depth))
+       if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
                return False;
 
        if(!prs_unistr4("name", ps, depth, &q_u->name))
                return False;
-       if(!prs_align(ps))
-               return False;
 
        return True;
 }
@@ -354,13 +351,13 @@ BOOL reg_io_q_delete_val(const char *desc, REG_Q_DELETE_VALUE *q_u,
 reads or writes a structure.
 ********************************************************************/
 
-BOOL reg_io_r_delete_val(const char *desc,  REG_R_DELETE_VALUE *r_u,
+BOOL reg_io_r_delete_value(const char *desc,  REG_R_DELETE_VALUE *r_u,
                          prs_struct *ps, int depth)
 {
        if ( !r_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_r_delete_val");
+       prs_debug(ps, depth, desc, "reg_io_r_delete_value");
        depth++;
 
        if(!prs_align(ps))
@@ -381,7 +378,7 @@ void init_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
 {
        ZERO_STRUCTP(q_c);
 
-       memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
+       memcpy(&q_c->handle, hnd, sizeof(q_c->handle));
 
        init_unistr4(&q_c->name, name, UNI_STR_TERMINATE);
 }
@@ -402,13 +399,11 @@ BOOL reg_io_q_delete_key(const char *desc,  REG_Q_DELETE_KEY *q_u,
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &q_u->pnt_pol, ps, depth))
+       if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
                return False;
 
        if(!prs_unistr4("", ps, depth, &q_u->name))
                return False;
-       if(!prs_align(ps))
-               return False;
 
        return True;
 }
@@ -438,12 +433,12 @@ BOOL reg_io_r_delete_key(const char *desc,  REG_R_DELETE_KEY *r_u, prs_struct *p
  Inits a structure.
 ********************************************************************/
 
-void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd, const char *class)
+void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd, const char *key_class)
 {
        ZERO_STRUCTP(q_o);
 
        memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
-       init_unistr4(&q_o->class, class, UNI_STR_TERMINATE);
+       init_unistr4(&q_o->key_class, key_class, UNI_STR_TERMINATE);
 }
 
 /*******************************************************************
@@ -463,10 +458,7 @@ BOOL reg_io_q_query_key(const char *desc,  REG_Q_QUERY_KEY *q_u, prs_struct *ps,
        
        if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
                return False;
-       if(!prs_unistr4("class", ps, depth, &q_u->class))
-               return False;
-
-       if(!prs_align(ps))
+       if(!prs_unistr4("key_class", ps, depth, &q_u->key_class))
                return False;
 
        return True;
@@ -488,7 +480,7 @@ BOOL reg_io_r_query_key(const char *desc,  REG_R_QUERY_KEY *r_u, prs_struct *ps,
        if(!prs_align(ps))
                return False;
        
-       if(!prs_unistr4("class", ps, depth, &r_u->class))
+       if(!prs_unistr4("key_class", ps, depth, &r_u->key_class))
                return False;
 
        if(!prs_align(ps))
@@ -563,7 +555,7 @@ BOOL reg_io_r_getversion(const char *desc,  REG_R_GETVERSION *r_u, prs_struct *p
        if(!prs_align(ps))
                return False;
 
-       if(!prs_uint32("unknown", ps, depth, &r_u->unknown))
+       if(!prs_uint32("win_version", ps, depth, &r_u->win_version))
                return False;
        if(!prs_werror("status" , ps, depth, &r_u->status))
                return False;
@@ -747,7 +739,7 @@ makes a structure.
 void init_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_u, POLICY_HND *pol,
                             uint32 sec_info, SEC_DESC_BUF *sec_desc_buf)
 {
-       memcpy(&q_u->pol, pol, sizeof(q_u->pol));
+       memcpy(&q_u->handle, pol, sizeof(q_u->handle));
 
        q_u->sec_info = sec_info;
 
@@ -771,7 +763,7 @@ BOOL reg_io_q_set_key_sec(const char *desc,  REG_Q_SET_KEY_SEC *q_u, prs_struct
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
+       if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
                return False;
 
        if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
@@ -815,7 +807,7 @@ void init_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_u, POLICY_HND *pol,
                             uint32 sec_info, uint32 sec_buf_size,
                             SEC_DESC_BUF *psdb)
 {
-       memcpy(&q_u->pol, pol, sizeof(q_u->pol));
+       memcpy(&q_u->handle, pol, sizeof(q_u->handle));
 
        q_u->sec_info = sec_info;
 
@@ -840,7 +832,7 @@ BOOL reg_io_q_get_key_sec(const char *desc,  REG_Q_GET_KEY_SEC *q_u, prs_struct
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
+       if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
                return False;
 
        if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
@@ -907,7 +899,7 @@ BOOL reg_io_r_get_key_sec(const char *desc,  REG_R_GET_KEY_SEC *q_u, prs_struct
 makes a structure.
 ********************************************************************/
 
-BOOL init_reg_q_info(REG_Q_INFO *q_u, POLICY_HND *pol, const char *val_name,
+BOOL init_reg_q_query_value(REG_Q_QUERY_VALUE *q_u, POLICY_HND *pol, const char *val_name,
                      REGVAL_BUFFER *value_output)
 {
         if (q_u == NULL)
@@ -938,12 +930,12 @@ BOOL init_reg_q_info(REG_Q_INFO *q_u, POLICY_HND *pol, const char *val_name,
 reads or writes a structure.
 ********************************************************************/
 
-BOOL reg_io_q_info(const char *desc,  REG_Q_INFO *q_u, prs_struct *ps, int depth)
+BOOL reg_io_q_query_value(const char *desc,  REG_Q_QUERY_VALUE *q_u, prs_struct *ps, int depth)
 {
        if ( !q_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_q_info");
+       prs_debug(ps, depth, desc, "reg_io_q_query_value");
        depth++;
 
        if(!prs_align(ps))
@@ -992,10 +984,10 @@ BOOL reg_io_q_info(const char *desc,  REG_Q_INFO *q_u, prs_struct *ps, int depth
 
 /*******************************************************************
  Inits a structure.
- New version to replace older init_reg_r_info()
+ New version to replace older init_reg_r_query_value()
 ********************************************************************/
 
-BOOL init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_u,
+BOOL init_reg_r_query_value(uint32 include_keyval, REG_R_QUERY_VALUE *r_u,
                     REGISTRY_VALUE *val, WERROR status)
 {
        uint32                  buf_len = 0;
@@ -1033,12 +1025,12 @@ BOOL init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_u,
 reads or writes a structure.
 ********************************************************************/
 
-BOOL reg_io_r_info(const char *desc, REG_R_INFO *r_u, prs_struct *ps, int depth)
+BOOL reg_io_r_query_value(const char *desc, REG_R_QUERY_VALUE *r_u, prs_struct *ps, int depth)
 {
        if ( !r_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_r_info");
+       prs_debug(ps, depth, desc, "reg_io_r_query_value");
        depth++;
 
        if(!prs_align(ps))
@@ -1219,7 +1211,7 @@ void init_reg_q_set_val(REG_Q_SET_VALUE *q_u, POLICY_HND *pol,
 {
        ZERO_STRUCTP(q_u);
 
-       memcpy(&q_u->pol, pol, sizeof(q_u->pol));
+       memcpy(&q_u->handle, pol, sizeof(q_u->handle));
 
        init_unistr4(&q_u->name, val_name, UNI_STR_TERMINATE);
        
@@ -1232,18 +1224,18 @@ void init_reg_q_set_val(REG_Q_SET_VALUE *q_u, POLICY_HND *pol,
 reads or writes a structure.
 ********************************************************************/
 
-BOOL reg_io_q_set_val(const char *desc,  REG_Q_SET_VALUE *q_u, prs_struct *ps, int depth)
+BOOL reg_io_q_set_value(const char *desc,  REG_Q_SET_VALUE *q_u, prs_struct *ps, int depth)
 {
        if (q_u == NULL)
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_q_set_val");
+       prs_debug(ps, depth, desc, "reg_io_q_set_value");
        depth++;
 
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
+       if(!smb_io_pol_hnd("", &q_u->handle, ps, depth))
                return False;
        
        if(!prs_unistr4("name", ps, depth, &q_u->name ))
@@ -1269,12 +1261,12 @@ BOOL reg_io_q_set_val(const char *desc,  REG_Q_SET_VALUE *q_u, prs_struct *ps, i
 reads or writes a structure.
 ********************************************************************/
 
-BOOL reg_io_r_set_val(const char *desc,  REG_R_SET_VALUE *q_u, prs_struct *ps, int depth)
+BOOL reg_io_r_set_value(const char *desc,  REG_R_SET_VALUE *q_u, prs_struct *ps, int depth)
 {
        if ( !q_u )
                return False;
 
-       prs_debug(ps, depth, desc, "reg_io_r_set_val");
+       prs_debug(ps, depth, desc, "reg_io_r_set_value");
        depth++;
 
        if(!prs_align(ps))
@@ -1318,7 +1310,7 @@ void init_reg_r_enum_key(REG_R_ENUM_KEY *r_u, char *subkey )
        if ( !r_u )
                return;
                
-       init_unistr4( &r_u->keyname, subkey, STR_TERMINATE );
+       init_unistr4( &r_u->keyname, subkey, UNI_STR_TERMINATE );
        r_u->classname = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
        r_u->time       = TALLOC_ZERO_P( get_talloc_ctx(), NTTIME );
 }
@@ -1458,21 +1450,6 @@ BOOL reg_io_q_open_entry(const char *desc,  REG_Q_OPEN_ENTRY *q_u, prs_struct *p
        return True;
 }
 
-/*******************************************************************
- Inits a structure.
-********************************************************************/
-
-void init_reg_r_open_entry(REG_R_OPEN_ENTRY *r_u,
-                          POLICY_HND *pol, WERROR werr)
-{
-       if (W_ERROR_IS_OK(werr)) {
-               memcpy(&r_u->pol, pol, sizeof(r_u->pol));
-       } else {
-               ZERO_STRUCT(r_u->pol);
-       }
-       r_u->status = werr;
-}
-
 /*******************************************************************
 reads or writes a structure.
 ********************************************************************/
@@ -1488,7 +1465,7 @@ BOOL reg_io_r_open_entry(const char *desc,  REG_R_OPEN_ENTRY *r_u, prs_struct *p
        if(!prs_align(ps))
                return False;
        
-       if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
+       if(!smb_io_pol_hnd("handle", &r_u->handle, ps, depth))
                return False;
 
        if(!prs_werror("status", ps, depth, &r_u->status))
@@ -1507,8 +1484,18 @@ void init_reg_q_shutdown(REG_Q_SHUTDOWN *q_u, const char *msg,
        q_u->server = TALLOC_P( get_talloc_ctx(), uint16 );
        *q_u->server = 0x1;
 
-       q_u->message = TALLOC_P( get_talloc_ctx(), UNISTR4 );
-       init_unistr4( q_u->message, msg, UNI_FLAGS_NONE );
+       q_u->message = TALLOC_ZERO_P( get_talloc_ctx(), UNISTR4 );
+
+       if ( msg && *msg ) { 
+               init_unistr4( q_u->message, msg, UNI_FLAGS_NONE );
+
+               /* Win2000 is apparently very sensitive to these lengths */
+               /* do a special case here */
+
+               q_u->message->string->uni_max_len++;
+               q_u->message->size += 2;
+
+       }
 
        q_u->timeout = timeout;
 
@@ -1558,6 +1545,8 @@ BOOL reg_io_q_shutdown(const char *desc, REG_Q_SHUTDOWN *q_u, prs_struct *ps,
 
        if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
                return False;
+       if (!prs_align(ps))
+               return False;
 
        if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
                return False;
@@ -1616,6 +1605,8 @@ BOOL reg_io_q_shutdown_ex(const char *desc, REG_Q_SHUTDOWN_EX *q_u, prs_struct *
 
        if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
                return False;
+       if (!prs_align(ps))
+               return False;
 
        if (!prs_pointer("message", ps, depth, (void**)&q_u->message, sizeof(UNISTR4), (PRS_POINTER_CAST)prs_unistr4))
                return False;
@@ -1689,6 +1680,8 @@ BOOL reg_io_q_abort_shutdown(const char *desc, REG_Q_ABORT_SHUTDOWN *q_u,
 
        if (!prs_pointer("server", ps, depth, (void**)&q_u->server, sizeof(uint16), (PRS_POINTER_CAST)prs_uint16))
                return False;
+       if (!prs_align(ps))
+               return False;
 
        return True;
 }