*
* 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/>.
*/
#include "includes.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_PARSE
-/*******************************************************************
- Reads or writes a SEC_ACCESS structure.
-********************************************************************/
-
-BOOL sec_io_access(const char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
-{
- if (t == NULL)
- return False;
-
- prs_debug(ps, depth, desc, "sec_io_access");
- depth++;
-
- if(!prs_uint32("mask", ps, depth, t))
- return False;
-
- return True;
-}
-
/*******************************************************************
Reads or writes a SEC_ACE structure.
********************************************************************/
-BOOL sec_io_ace(const char *desc, SEC_ACE *psa, prs_struct *ps, int depth)
+static bool sec_io_ace(const char *desc, SEC_ACE *psa, prs_struct *ps,
+ int depth)
{
uint32 old_offset;
uint32 offset_ace_size;
+ uint8 type;
if (psa == NULL)
return False;
old_offset = prs_offset(ps);
- if(!prs_uint8("type ", ps, depth, (uint8*)&psa->type))
+ if (MARSHALLING(ps)) {
+ type = (uint8)psa->type;
+ }
+
+ if(!prs_uint8("type ", ps, depth, &type))
return False;
+ if (UNMARSHALLING(ps)) {
+ psa->type = (enum security_ace_type)type;
+ }
+
if(!prs_uint8("flags", ps, depth, &psa->flags))
return False;
if (!prs_uint32("obj_flags", ps, depth, &psa->object.object.flags))
return False;
- if (psa->object.object.flags & SEC_ACE_OBJECT_PRESENT)
+ if (psa->object.object.flags & SEC_ACE_OBJECT_TYPE_PRESENT)
if (!smb_io_uuid("obj_guid", &psa->object.object.type.type, ps,depth))
return False;
- if (psa->object.object.flags & SEC_ACE_OBJECT_INHERITED_PRESENT)
+ if (psa->object.object.flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)
if (!smb_io_uuid("inh_guid", &psa->object.object.inherited_type.inherited_type, ps,depth))
return False;
for you as it reads them.
********************************************************************/
-BOOL sec_io_acl(const char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth)
+static bool sec_io_acl(const char *desc, SEC_ACL **ppsa, prs_struct *ps,
+ int depth)
{
unsigned int i;
uint32 old_offset;
uint32 offset_acl_size;
SEC_ACL *psa;
+ uint16 revision;
/*
* Note that the size is always a multiple of 4 bytes due to the
old_offset = prs_offset(ps);
- if(!prs_uint16("revision", ps, depth, (uint16 *)&psa->revision))
+ if (MARSHALLING(ps)) {
+ revision = (uint16)psa->revision;
+ }
+
+ if(!prs_uint16("revision", ps, depth, &revision))
return False;
+ if (UNMARSHALLING(ps)) {
+ psa->revision = (enum security_acl_revision)revision;
+ }
+
if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_acl_size))
return False;
return False;
if (UNMARSHALLING(ps)) {
- /*
- * Even if the num_aces is zero, allocate memory as there's a difference
- * between a non-present DACL (allow all access) and a DACL with no ACE's
- * (allow no access).
- */
- if((psa->aces = PRS_ALLOC_MEM(ps, SEC_ACE, psa->num_aces+1)) == NULL)
- return False;
+ if (psa->num_aces) {
+ if((psa->aces = PRS_ALLOC_MEM(ps, SEC_ACE, psa->num_aces)) == NULL)
+ return False;
+ } else {
+ psa->aces = NULL;
+ }
}
for (i = 0; i < psa->num_aces; i++) {
If reading and the *ppsd = NULL, allocates the structure.
********************************************************************/
-BOOL sec_io_desc(const char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
+bool sec_io_desc(const char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
{
uint32 old_offset;
uint32 max_offset = 0; /* after we're done, move offset to end */
uint32 tmp_offset = 0;
uint32 off_sacl, off_dacl, off_owner_sid, off_grp_sid;
+ uint16 revision;
SEC_DESC *psd;
/* start of security descriptor stored for back-calc offset purposes */
old_offset = prs_offset(ps);
- if(!prs_uint16("revision ", ps, depth, (uint16*)&psd->revision))
+ if (MARSHALLING(ps)) {
+ revision = (uint16)psd->revision;
+ }
+
+ if(!prs_uint16("revision", ps, depth, &revision))
return False;
+ if (UNMARSHALLING(ps)) {
+ psd->revision = (enum security_descriptor_revision)revision;
+ }
+
if(!prs_uint16("type ", ps, depth, &psd->type))
return False;
if (psd->owner_sid != NULL) {
off_owner_sid = offset;
- offset += sid_size(psd->owner_sid);
+ offset += ndr_size_dom_sid(psd->owner_sid, NULL, 0);
} else {
off_owner_sid = 0;
}
if (psd->group_sid != NULL) {
off_grp_sid = offset;
- offset += sid_size(psd->group_sid);
+ offset += ndr_size_dom_sid(psd->group_sid, NULL, 0);
} else {
off_grp_sid = 0;
}
Reads or writes a SEC_DESC_BUF structure.
********************************************************************/
-BOOL sec_io_desc_buf(const char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
+bool sec_io_desc_buf(const char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
{
uint32 off_len;
uint32 off_max_len;
if(!prs_uint32 ("ptr ", ps, depth, &ptr))
return False;
- len = sec_desc_size(psdb->sd);
+ len = ndr_size_security_descriptor(psdb->sd, NULL, 0);
if(!prs_uint32_pre("len ", ps, depth, &len, &off_len))
return False;
git.samba.org / metze / samba / wip.git / blobdiff