summaryrefslogtreecommitdiff
path: root/source3/rpc_parse
diff options
context:
space:
mode:
authorLuke Leighton <lkcl@samba.org>1998-11-12 23:35:05 +0000
committerLuke Leighton <lkcl@samba.org>1998-11-12 23:35:05 +0000
commit2c7f6da1fa95ff77d6c60fcd109205847519434f (patch)
treed52fbd3a92e235ce15a1670efa30f8c0bea21a02 /source3/rpc_parse
parentc1bf51bd2c993c09c67ff003c6fba4edd5b350bd (diff)
downloadsamba-2c7f6da1fa95ff77d6c60fcd109205847519434f.tar.gz
samba-2c7f6da1fa95ff77d6c60fcd109205847519434f.tar.bz2
samba-2c7f6da1fa95ff77d6c60fcd109205847519434f.zip
security descriptors.
kanji const char* warnings. (This used to be commit 06abdfd68e1d7fa8741afc3f56ec7a13b5fa4ccc)
Diffstat (limited to 'source3/rpc_parse')
-rw-r--r--source3/rpc_parse/parse_reg.c24
-rw-r--r--source3/rpc_parse/parse_sec.c270
2 files changed, 268 insertions, 26 deletions
diff --git a/source3/rpc_parse/parse_reg.c b/source3/rpc_parse/parse_reg.c
index f22bf10ff8..103e6b0f85 100644
--- a/source3/rpc_parse/parse_reg.c
+++ b/source3/rpc_parse/parse_reg.c
@@ -125,7 +125,7 @@ creates a structure.
********************************************************************/
void make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
char *name, char *class,
- SEC_INFO *sam_access)
+ SEC_ACCESS *sam_access)
{
int len_name = name != NULL ? strlen(name ) + 1: 0;
int len_class = class != NULL ? strlen(class) + 1: 0;
@@ -191,7 +191,7 @@ void reg_io_q_create_key(char *desc, REG_Q_CREATE_KEY *r_q, prs_struct *ps, int
prs_align(ps);
prs_uint32("reserved", ps, depth, &(r_q->reserved));
- sec_io_info("sam_access", &r_q->sam_access, ps, depth);
+ sec_io_access("sam_access", &r_q->sam_access, ps, depth);
prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
if (r_q->ptr2 != 0)
@@ -551,11 +551,11 @@ void make_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol,
memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
- q_i->unknown = 0x4;
+ 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_sec_desc_buf(q_i->data, buf_len, sec_desc);
}
/*******************************************************************
@@ -572,7 +572,7 @@ void reg_io_q_set_key_sec(char *desc, REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, i
smb_io_pol_hnd("", &(r_q->pol), ps, depth);
- prs_uint32("unknown", ps, depth, &(r_q->unknown));
+ prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
if (r_q->ptr != 0)
@@ -581,10 +581,10 @@ void reg_io_q_set_key_sec(char *desc, REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, i
uint32 old_offset;
smb_io_hdrbuf_pre("hdr_sec", &(r_q->hdr_sec), ps, depth, &hdr_offset);
old_offset = ps->offset;
- sec_io_desc_buf("data ", &(r_q->data ), ps, depth);
+ sec_io_desc_buf("data ", r_q->data , ps, depth);
smb_io_hdrbuf_post("hdr_sec", &(r_q->hdr_sec), ps, depth, hdr_offset,
- r_q->data.max_len, r_q->data.len);
- ps->offset = old_offset + r_q->data.len + sizeof(uint32) * 3;
+ r_q->data->max_len, r_q->data->len);
+ ps->offset = old_offset + r_q->data->len + sizeof(uint32) * 3;
prs_align(ps);
}
}
@@ -615,7 +615,9 @@ void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
- q_i->unknown = 0x7;
+ q_i->sec_info = OWNER_SECURITY_INFORMATION |
+ GROUP_SECURITY_INFORMATION |
+ DACL_SECURITY_INFORMATION;
q_i->ptr = sec_buf != NULL ? 1 : 0;
q_i->data = sec_buf;
@@ -641,8 +643,8 @@ void reg_io_q_get_key_sec(char *desc, REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, i
smb_io_pol_hnd("", &(r_q->pol), ps, depth);
- prs_uint32("unknown", ps, depth, &(r_q->unknown));
- prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
+ prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
+ prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
if (r_q->ptr != 0)
{
diff --git a/source3/rpc_parse/parse_sec.c b/source3/rpc_parse/parse_sec.c
index 7ef6914108..b3c75fb0dc 100644
--- a/source3/rpc_parse/parse_sec.c
+++ b/source3/rpc_parse/parse_sec.c
@@ -1,11 +1,11 @@
-
/*
* Unix SMB/Netbios implementation.
* Version 1.9.
* RPC Pipe client / server routines
- * Copyright (C) Andrew Tridgell 1992-1997,
- * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
- * Copyright (C) Paul Ashton 1997.
+ * Copyright (C) Andrew Tridgell 1992-1998,
+ * Copyright (C) Jeremy R. Allison 1995-1998
+ * Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
+ * Copyright (C) Paul Ashton 1997-1998.
*
* 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
@@ -29,18 +29,40 @@ extern int DEBUGLEVEL;
/*******************************************************************
+makes a structure.
+********************************************************************/
+void make_sec_access(SEC_ACCESS *t, uint32 mask)
+{
+ t->mask = mask;
+}
+
+/*******************************************************************
reads or writes a structure.
********************************************************************/
-void sec_io_info(char *desc, SEC_INFO *t, prs_struct *ps, int depth)
+void sec_io_access(char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
{
if (t == NULL) return;
- prs_debug(ps, depth, desc, "sec_io_info");
+ prs_debug(ps, depth, desc, "sec_io_access");
depth++;
prs_align(ps);
- prs_uint32("perms", ps, depth, &(t->perms));
+ prs_uint32("mask", ps, depth, &(t->mask));
+}
+
+
+/*******************************************************************
+makes a structure.
+********************************************************************/
+void make_sec_ace(SEC_ACE *t, DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag)
+{
+ t->type = type;
+ t->flags = flag;
+ t->size = sid_size(sid) + 8;
+ t->info = mask;
+
+ sid_copy(&t->sid, sid);
}
/*******************************************************************
@@ -63,7 +85,7 @@ void sec_io_ace(char *desc, SEC_ACE *t, prs_struct *ps, int depth)
prs_uint8 ("flags", ps, depth, &(t->flags));
prs_uint16_pre("size ", ps, depth, &(t->size ), &offset_ace_size);
- sec_io_info ("info ", &t->info, ps, depth);
+ sec_io_access ("info ", &t->info, ps, depth);
prs_align(ps);
smb_io_dom_sid("sid ", &t->sid , ps, depth);
@@ -71,8 +93,38 @@ void sec_io_ace(char *desc, SEC_ACE *t, prs_struct *ps, int depth)
}
/*******************************************************************
-reads or writes a structure. this is one of those retrospective jobs,
-which i hate. why do we have to do this? what's it all about?
+makes a structure.
+********************************************************************/
+void make_sec_acl(SEC_ACL *t, uint16 revision, int num_aces, SEC_ACE *ace)
+{
+ int i;
+ t->revision = revision;
+ t->num_aces = num_aces;
+ t->size = 4;
+ t->ace = ace;
+
+ for (i = 0; i < num_aces; i++)
+ {
+ t->size += ace[i].size;
+ }
+}
+
+/*******************************************************************
+frees a structure.
+********************************************************************/
+void free_sec_acl(SEC_ACL *t)
+{
+ if (t->ace != NULL)
+ {
+ free(t->ace);
+ }
+}
+
+/*******************************************************************
+reads or writes a structure.
+
+first of the xx_io_xx functions that allocates its data structures
+for you as it reads them.
********************************************************************/
void sec_io_acl(char *desc, SEC_ACL *t, prs_struct *ps, int depth)
{
@@ -93,6 +145,20 @@ void sec_io_acl(char *desc, SEC_ACL *t, prs_struct *ps, int depth)
prs_uint16_pre("size ", ps, depth, &(t->size ), &offset_acl_size);
prs_uint32("num_aces ", ps, depth, &(t->num_aces ));
+ if (ps->io && t->num_aces != 0)
+ {
+ /* reading */
+ t->ace = malloc(sizeof(t->ace[0]) * t->num_aces);
+ ZERO_STRUCTPN(t->ace);
+ }
+
+ if (t->ace == NULL && t->num_aces != 0)
+ {
+ DEBUG(0,("INVALID ACL\n"));
+ ps->offset = 0xfffffffe;
+ return;
+ }
+
for (i = 0; i < MIN(t->num_aces, MAX_SEC_ACES); i++)
{
fstring tmp;
@@ -107,6 +173,85 @@ void sec_io_acl(char *desc, SEC_ACL *t, prs_struct *ps, int depth)
/*******************************************************************
+makes a structure
+********************************************************************/
+int make_sec_desc(SEC_DESC *t, uint16 revision, uint16 type,
+ DOM_SID *owner_sid, DOM_SID *grp_sid,
+ SEC_ACL *sacl, SEC_ACL *dacl)
+{
+ uint32 offset;
+
+ t->revision = revision;
+ t->type = type;
+
+ t->off_owner_sid = 0;
+ t->off_grp_sid = 0;
+ t->off_sacl = 0;
+ t->off_dacl = 0;
+
+ t->dacl = dacl;
+ t->sacl = sacl;
+ t->owner_sid = owner_sid;
+ t->grp_sid = grp_sid;
+
+ offset = 0x14;
+
+ if (dacl != NULL)
+ {
+ t->off_dacl = offset;
+ offset += dacl->size;
+ }
+
+ if (sacl != NULL)
+ {
+ t->off_dacl = offset;
+ offset += dacl->size;
+ }
+
+ if (owner_sid != NULL)
+ {
+ t->off_owner_sid = offset;
+ offset += sid_size(owner_sid);
+ }
+
+ if (grp_sid != NULL)
+ {
+ t->off_grp_sid = offset;
+ offset += sid_size(grp_sid);
+ }
+
+ return offset;
+}
+
+
+/*******************************************************************
+frees a structure
+********************************************************************/
+void free_sec_desc(SEC_DESC *t)
+{
+ if (t->dacl != NULL)
+ {
+ free_sec_acl(t->dacl);
+ }
+
+ if (t->sacl != NULL)
+ {
+ free_sec_acl(t->dacl);
+ }
+
+ if (t->owner_sid != NULL)
+ {
+ free(t->owner_sid);
+ }
+
+ if (t->grp_sid != NULL)
+ {
+ free(t->grp_sid);
+ }
+}
+
+
+/*******************************************************************
reads or writes a structure.
********************************************************************/
static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
@@ -114,8 +259,9 @@ static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
uint32 off_owner_sid;
uint32 off_grp_sid ;
uint32 off_sacl ;
- uint32 off_dacl ;
+ uint32 off_dacl ;
uint32 old_offset;
+ uint32 max_offset = 0; /* after we're done, move offset to end */
if (t == NULL) return;
@@ -135,11 +281,27 @@ static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
prs_uint32_pre("off_sacl ", ps, depth, &(t->off_sacl ), &off_sacl );
prs_uint32_pre("off_dacl ", ps, depth, &(t->off_dacl ), &off_dacl );
+ max_offset = MAX(max_offset, ps->offset);
+
if (IS_BITS_SET_ALL(t->type, SEC_DESC_DACL_PRESENT))
{
prs_uint32_post("off_dacl ", ps, depth, &(t->off_dacl ), off_dacl , ps->offset - old_offset);
ps->offset = old_offset + t->off_dacl;
- sec_io_acl ("dacl" , &t->dacl , ps, depth);
+ if (ps->io)
+ {
+ /* reading */
+ t->dacl = malloc(sizeof(*t->dacl));
+ ZERO_STRUCTPN(t->dacl);
+ }
+
+ if (t->dacl == NULL)
+ {
+ DEBUG(0,("INVALID DACL\n"));
+ ps->offset = 0xfffffffe;
+ return;
+ }
+
+ sec_io_acl ("dacl" , t->dacl , ps, depth);
prs_align(ps);
}
else
@@ -147,11 +309,27 @@ static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
prs_uint32_post("off_dacl ", ps, depth, &(t->off_dacl ), off_dacl , 0);
}
+ max_offset = MAX(max_offset, ps->offset);
+
if (IS_BITS_SET_ALL(t->type, SEC_DESC_SACL_PRESENT))
{
prs_uint32_post("off_sacl ", ps, depth, &(t->off_sacl ), off_sacl , ps->offset - old_offset);
ps->offset = old_offset + t->off_sacl;
- sec_io_acl ("sacl" , &t->sacl , ps, depth);
+ if (ps->io)
+ {
+ /* reading */
+ t->sacl = malloc(sizeof(*t->sacl));
+ ZERO_STRUCTPN(t->sacl);
+ }
+
+ if (t->sacl == NULL)
+ {
+ DEBUG(0,("INVALID SACL\n"));
+ ps->offset = 0xfffffffe;
+ return;
+ }
+
+ sec_io_acl ("sacl" , t->sacl , ps, depth);
prs_align(ps);
}
else
@@ -159,6 +337,8 @@ static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
prs_uint32_post("off_sacl ", ps, depth, &(t->off_sacl ), off_sacl , 0);
}
+ max_offset = MAX(max_offset, ps->offset);
+
prs_uint32_post("off_owner_sid", ps, depth, &(t->off_owner_sid), off_owner_sid, ps->offset - old_offset);
if (t->off_owner_sid != 0)
{
@@ -166,10 +346,26 @@ static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
{
ps->offset = old_offset + t->off_owner_sid;
}
- smb_io_dom_sid("owner_sid ", &t->owner_sid , ps, depth);
+ if (ps->io)
+ {
+ /* reading */
+ t->owner_sid = malloc(sizeof(*t->owner_sid));
+ ZERO_STRUCTPN(t->owner_sid);
+ }
+
+ if (t->owner_sid == NULL)
+ {
+ DEBUG(0,("INVALID OWNER SID\n"));
+ ps->offset = 0xfffffffe;
+ return;
+ }
+
+ smb_io_dom_sid("owner_sid ", t->owner_sid , ps, depth);
prs_align(ps);
}
+ max_offset = MAX(max_offset, ps->offset);
+
prs_uint32_post("off_grp_sid ", ps, depth, &(t->off_grp_sid ), off_grp_sid , ps->offset - old_offset);
if (t->off_grp_sid != 0)
{
@@ -177,9 +373,27 @@ static void sec_io_desc(char *desc, SEC_DESC *t, prs_struct *ps, int depth)
{
ps->offset = old_offset + t->off_grp_sid;
}
- smb_io_dom_sid("grp_sid", &t->grp_sid, ps, depth);
+ if (ps->io)
+ {
+ /* reading */
+ t->grp_sid = malloc(sizeof(*t->grp_sid));
+ ZERO_STRUCTPN(t->grp_sid);
+ }
+
+ if (t->grp_sid == NULL)
+ {
+ DEBUG(0,("INVALID GROUP SID\n"));
+ ps->offset = 0xfffffffe;
+ return;
+ }
+
+ smb_io_dom_sid("grp_sid", t->grp_sid, ps, depth);
prs_align(ps);
}
+
+ max_offset = MAX(max_offset, ps->offset);
+
+ ps->offset = max_offset;
}
/*******************************************************************
@@ -196,6 +410,18 @@ void make_sec_desc_buf(SEC_DESC_BUF *buf, int len, SEC_DESC *data)
buf->sec = data;
}
+/*******************************************************************
+frees a SEC_DESC_BUF structure.
+********************************************************************/
+void free_sec_desc_buf(SEC_DESC_BUF *buf)
+{
+ if (buf->sec != NULL)
+ {
+ free_sec_desc(buf->sec);
+ free(buf->sec);
+ }
+}
+
/*******************************************************************
reads or writes a SEC_DESC_BUF structure.
@@ -220,6 +446,20 @@ void sec_io_desc_buf(char *desc, SEC_DESC_BUF *sec, prs_struct *ps, int depth)
old_offset = ps->offset;
+ if (sec->len != 0 && ps->io)
+ {
+ /* reading */
+ sec->sec = malloc(sizeof(*sec->sec));
+ ZERO_STRUCTPN(sec->sec);
+
+ if (sec->sec == NULL)
+ {
+ DEBUG(0,("INVALID SEC_DESC\n"));
+ ps->offset = 0xfffffffe;
+ return;
+ }
+ }
+
/* reading, length is non-zero; writing, descriptor is non-NULL */
if ((sec->len != 0 || (!ps->io)) && sec->sec != NULL)
{