added jeremy's new c++-like code for parsing of security descriptors.

[samba.git] / source3 / rpc_parse / parse_reg.c

diff --git a/source3/rpc_parse/parse_reg.c b/source3/rpc_parse/parse_reg.c
index a3d8ebb64a645ead6a17b434a5918d76c742a7e2..5512f784999b2e2eee8c149f52ecb135a5a22534 100644 (file)
--- a/source3/rpc_parse/parse_reg.c
+++ b/source3/rpc_parse/parse_reg.c
@@ -135,7 +135,8 @@ static void reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec, SEC_DES
                }
                if (ptr3 == NULL || *ptr3 != 0)
                {
-                       sec_io_desc_buf("data   ", data   , ps, depth);
+                       /* JRA - this line is probably wrong... */
+                       sec_io_desc_buf("data   ", &data   , ps, depth);
                }
                smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth, hdr_offset,
                                   data->max_len, data->len);
@@ -145,15 +146,13 @@ static void reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec, SEC_DES
 }
 
 
-
 /*******************************************************************
 creates a structure.
 ********************************************************************/
 void make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
                                char *name, char *class,
                                SEC_ACCESS *sam_access,
-                               SEC_DESC_BUF *sec_buf,
-                               int sec_len, SEC_DESC *sec)
+                               SEC_DESC_BUF *sec_buf)
 {
        int len_name  = name  != NULL ? strlen(name ) + 1: 0;
        int len_class = class != NULL ? strlen(class) + 1: 0;
@@ -176,9 +175,8 @@ void make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
 
        q_c->data = sec_buf;
        q_c->ptr2 = 1;
-       make_buf_hdr(&(q_c->hdr_sec), sec_len, sec_len);
+       make_buf_hdr(&(q_c->hdr_sec), sec_buf->len, sec_buf->len);
        q_c->ptr3 = 1;
-       make_sec_desc_buf(q_c->data, sec_len, sec);
 
        q_c->unknown_2 = 0x00000000;
 }
@@ -547,8 +545,8 @@ void reg_io_r_close(char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
 /*******************************************************************
 makes a structure.
 ********************************************************************/
-void make_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol, 
-                               uint32 buf_len, SEC_DESC *sec_desc)
+void make_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol,
+                               SEC_DESC_BUF *sec_desc_buf)
 {
        if (q_i == NULL) return;
 
@@ -557,8 +555,8 @@ void make_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol,
        q_i->sec_info = DACL_SECURITY_INFORMATION;
 
        q_i->ptr = 1;
-       make_buf_hdr(&(q_i->hdr_sec), buf_len, buf_len);
-       make_sec_desc_buf(q_i->data, buf_len, sec_desc);
+       make_buf_hdr(&(q_i->hdr_sec), sec_desc_buf->len, sec_desc_buf->len);
+       q_i->data = sec_desc_buf;
 }
 
 /*******************************************************************
@@ -601,7 +599,7 @@ void reg_io_r_set_key_sec(char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, in
 makes a structure.
 ********************************************************************/
 void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol, 
-                               uint32 buf_len, SEC_DESC_BUF *sec_buf)
+                               uint32 sec_buf_size, SEC_DESC_BUF *psdb)
 {
        if (q_i == NULL) return;
 
@@ -611,14 +609,10 @@ void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
                        GROUP_SECURITY_INFORMATION |
                        DACL_SECURITY_INFORMATION;
 
-       q_i->ptr = sec_buf != NULL ? 1 : 0;
-       q_i->data = sec_buf;
+       q_i->ptr = psdb != NULL ? 1 : 0;
+       q_i->data = psdb;
 
-       if (sec_buf != NULL)
-       {
-               make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
-               make_sec_desc_buf(q_i->data, buf_len, NULL);
-       }
+       make_buf_hdr(&(q_i->hdr_sec), sec_buf_size, 0);
 }
 
 /*******************************************************************
@@ -675,8 +669,7 @@ void reg_io_r_get_key_sec(char *desc,  REG_R_GET_KEY_SEC *r_q, prs_struct *ps, i
 
        if (r_q->ptr != 0)
        {
-               smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
-               sec_io_desc_buf("", r_q->data, ps, depth);
+               sec_io_desc_buf("", &r_q->data, ps, depth);
 
                prs_align(ps);
        }
@@ -769,19 +762,21 @@ void make_reg_r_info(REG_R_INFO *r_r,
                                uint32 status)
 {
        char buf[512];
-       int len = struni2(buf, os_type);
+       int len;
+
+       len = ascii_to_unibuf(buf, os_type, sizeof(buf)-2) - buf;
 
        r_r->ptr1 = 1;
        r_r->level = level;
 
        r_r->ptr_type = 1;
-       make_buffer2(&(r_r->uni_type), buf, len*2);
+       make_buffer2(&(r_r->uni_type), buf, len);
 
        r_r->ptr2 = 1;
-       r_r->unknown_0 = len*2;
+       r_r->unknown_0 = len;
 
        r_r->ptr3 = 1;
-       r_r->unknown_1 = len*2;
+       r_r->unknown_1 = len;
 
        r_r->status = status;
 }
@@ -806,6 +801,7 @@ void reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
                prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
 
                smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
+               prs_align(ps);
 
                prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
 
@@ -1178,3 +1174,66 @@ void reg_io_r_open_entry(char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int
        prs_uint32("status", ps, depth, &(r_r->status));
 }
 
+/*******************************************************************
+makes a structure.
+********************************************************************/
+void make_reg_q_shutdown(REG_Q_SHUTDOWN *q_i,
+                               char *msg, uint32 timeout, uint16 flags)
+{
+       int len = strlen(msg) + 1;
+
+       if (q_i == NULL) return;
+
+       ZERO_STRUCTP(q_i);
+
+       q_i->ptr_0 = 1;
+       q_i->ptr_1 = 1;
+       q_i->ptr_2 = 1;
+
+       make_uni_hdr(&q_i->hdr_msg, len, len, 1);
+       make_unistr2(&(q_i->uni_msg), msg, len);
+       
+       q_i->timeout = timeout;
+       q_i->flags   = flags;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void reg_io_q_shutdown(char *desc,  REG_Q_SHUTDOWN *q_q, prs_struct *ps, int depth)
+{
+       if (q_q == NULL) return;
+
+       prs_debug(ps, depth, desc, "reg_io_q_shutdown");
+       depth++;
+
+       prs_align(ps);
+       
+       prs_uint32("ptr_0", ps, depth, &(q_q->ptr_0));
+       prs_uint32("ptr_1", ps, depth, &(q_q->ptr_1));
+       prs_uint32("ptr_2", ps, depth, &(q_q->ptr_2));
+       
+       smb_io_unihdr ("hdr_msg", &(q_q->hdr_msg), ps, depth);
+       smb_io_unistr2("uni_msg", &(q_q->uni_msg), q_q->hdr_msg.buffer, ps, depth);
+       prs_align(ps);
+
+       prs_uint32("timeout", ps, depth, &(q_q->timeout));
+       prs_uint16("flags  ", ps, depth, &(q_q->flags  ));
+       prs_align(ps);
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void reg_io_r_shutdown(char *desc,  REG_R_SHUTDOWN *r_q, prs_struct *ps, int depth)
+{
+       if (r_q == NULL) return;
+
+       prs_debug(ps, depth, desc, "reg_io_r_shutdown");
+       depth++;
+
+       prs_align(ps);
+       
+       prs_uint32("status", ps, depth, &(r_q->status));
+}
+