Context Navigation

source: trunk/lib/smb_deps.c @ 37

Last change on this file since 37 was 31, checked in by tim, 19 years ago

Added new lightweight stack library

rewrote test program to use this instead of string concatenation/recursion.

Property svn:keywords set to Id

File size: 24.9 KB

Rev	Line
[30]	1	/*
	2	* This file contains miscellaneous pieces of code which regfio.c
	3	* depends upon, from the Samba Subversion tree. See:
	4	* http://websvn.samba.org/cgi-bin/viewcvs.cgi/trunk/source/
	5	*
	6	* Copyright (C) 2005 Timothy D. Morgan
	7	* Copyright (C) 1992-2005 Samba development team
	8	* (see individual files under Subversion for details.)
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; version 2 of the License.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	22	*
	23	* $Id: smb_deps.c 31 2005-07-16 19:05:19Z tim $
	24	*/
	25
	26	#include "../include/smb_deps.h"
	27
	28
	29	/* These act as replacements for numerous Samba memory allocation
	30	* functions.
	31	*/
	32	void* zalloc(size_t size)
	33	{
	34	void* ret_val = NULL;
[31]	35	if((ret_val = (void*)malloc(size)) != NULL)
[30]	36	memset(ret_val, 0, size);
	37	return ret_val;
	38	}
	39
	40	void* zcalloc(size_t size, unsigned int count)
	41	{
	42	return zalloc(size*count);
	43	}
	44
	45	/* From lib/time.c */
	46
	47	/****************************************************************************
	48	Put a 8 byte filetime from a time_t
	49	This takes real GMT as input and converts to kludge-GMT
	50	****************************************************************************/
	51	void unix_to_nt_time(NTTIME *nt, time_t t)
	52	{
	53	double d;
	54
	55	if (t==0) {
	56	nt->low = 0;
	57	nt->high = 0;
	58	return;
	59	}
	60	if (t == TIME_T_MAX) {
	61	nt->low = 0xffffffff;
	62	nt->high = 0x7fffffff;
	63	return;
	64	}
	65	if (t == -1) {
	66	nt->low = 0xffffffff;
	67	nt->high = 0xffffffff;
	68	return;
	69	}
	70
	71	/* this converts GMT to kludge-GMT */
	72	/XXX t -= TimeDiff(t) - get_serverzone(); /
	73
	74	d = (double)(t);
	75	d += TIME_FIXUP_CONSTANT;
	76	d *= 1.0e7;
	77
	78	nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
	79	nt->low = (uint32)(d - ((double)nt->high)4.0(double)(1<<30));
	80	}
	81
	82	/* End of stuff from lib/time.c */
	83
	84	/* From parse_prs.c */
	85
	86	/*******************************************************************
	87	Attempt, if needed, to grow a data buffer.
	88	Also depends on the data stream mode (io).
	89	********************************************************************/
	90	bool prs_grow(prs_struct *ps, uint32 extra_space)
	91	{
	92	uint32 new_size;
	93	char *new_data;
	94
	95	ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
	96
	97	if(ps->data_offset + extra_space <= ps->buffer_size)
	98	return true;
	99
	100	/*
	101	* We cannot grow the buffer if we're not reading
	102	* into the prs_struct, or if we don't own the memory.
	103	*/
	104
	105	if(ps->io \|\| !ps->is_dynamic) {
	106	return false;
	107	}
	108
	109	/*
	110	* Decide how much extra space we really need.
	111	*/
	112
	113	extra_space -= (ps->buffer_size - ps->data_offset);
	114	if(ps->buffer_size == 0) {
	115	/*
	116	* Ensure we have at least a PDU's length, or extra_space, whichever
	117	* is greater.
	118	*/
	119
	120	new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);
	121
	122	if((new_data = zalloc(new_size)) == NULL) {
	123	return false;
	124	}
	125	memset(new_data, '\0', (size_t)new_size );
	126	} else {
	127	/*
	128	* If the current buffer size is bigger than the space needed, just
	129	* double it, else add extra_space.
	130	*/
	131	new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);
	132
	133	if ((new_data = (char*)realloc(ps->data_p, new_size)) == NULL) {
	134	return false;
	135	}
	136
	137	memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
	138	}
	139	ps->buffer_size = new_size;
	140	ps->data_p = new_data;
	141
	142	return true;
	143	}
	144
	145
	146	/*******************************************************************
	147	Align a the data_len to a multiple of align bytes - filling with
	148	zeros.
	149	********************************************************************/
	150	bool prs_align(prs_struct *ps)
	151	{
	152	uint32 mod = ps->data_offset & (ps->align-1);
	153
	154	if (ps->align != 0 && mod != 0) {
	155	uint32 extra_space = (ps->align - mod);
	156	if(!prs_grow(ps, extra_space))
	157	return false;
	158	memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
	159	ps->data_offset += extra_space;
	160	}
	161
	162	return true;
	163	}
	164
	165
	166	/**
	167	* Initialise an expandable parse structure.
	168	*
	169	* @param size Initial buffer size. If >0, a new buffer will be
	170	* created with malloc().
	171	*
	172	* @return false if allocation fails, otherwise true.
	173	**/
	174
	175	bool prs_init(prs_struct ps, uint32 size, void ctx, bool io)
	176	{
[31]	177	memset(ps, 0, sizeof(prs_struct));
	178	ps->io = io;
	179	ps->bigendian_data = RPC_LITTLE_ENDIAN;
	180	ps->align = RPC_PARSE_ALIGN;
	181	ps->is_dynamic = false;
	182	ps->data_offset = 0;
	183	ps->buffer_size = 0;
	184	ps->data_p = NULL;
	185	ps->mem_ctx = ctx;
	186
	187	if (size != 0) {
	188	ps->buffer_size = size;
	189	if((ps->data_p = (char *)zalloc((size_t)size)) == NULL) {
	190	return false;
	191	}
	192	memset(ps->data_p, '\0', (size_t)size);
	193	ps->is_dynamic = true; /* We own this memory. */
	194	}
	195
	196	return true;
[30]	197	}
	198
	199
	200	char prs_mem_get(prs_struct ps, uint32 extra_size)
	201	{
	202	if(ps->io) {
	203	/*
	204	* If reading, ensure that we can read the requested size item.
	205	*/
	206	if (ps->data_offset + extra_size > ps->buffer_size) {
	207	return NULL;
	208	}
	209	} else {
	210	/*
	211	* Writing - grow the buffer if needed.
	212	*/
	213	if(!prs_grow(ps, extra_size))
	214	return NULL;
	215	}
	216	return &ps->data_p[ps->data_offset];
	217	}
	218
	219
	220	/*******************************************************************
	221	Stream a uint32.
	222	********************************************************************/
	223	bool prs_uint32(const char name, prs_struct ps, int depth, uint32 *data32)
	224	{
	225	char *q = prs_mem_get(ps, sizeof(uint32));
	226	if (q == NULL)
	227	return false;
	228
	229	if (ps->io) {
	230	if (ps->bigendian_data)
	231	*data32 = RIVAL(q,0);
	232	else
	233	*data32 = IVAL(q,0);
	234	} else {
	235	if (ps->bigendian_data)
	236	RSIVAL(q,0,*data32);
	237	else
	238	SIVAL(q,0,*data32);
	239	}
	240
	241	ps->data_offset += sizeof(uint32);
	242
	243	return true;
	244	}
	245
	246
	247	/******************************************************************
	248	Stream an array of uint32s. Length is number of uint32s.
	249	********************************************************************/
	250	bool prs_uint32s(bool charmode, const char name, prs_struct ps,
	251	int depth, uint32 *data32s, int len)
	252	{
	253	int i;
	254	char q = prs_mem_get(ps, len sizeof(uint32));
	255	if (q == NULL)
	256	return false;
	257
	258	if (ps->io) {
	259	if (ps->bigendian_data) {
	260	for (i = 0; i < len; i++)
	261	data32s[i] = RIVAL(q, 4*i);
	262	} else {
	263	for (i = 0; i < len; i++)
	264	data32s[i] = IVAL(q, 4*i);
	265	}
	266	} else {
	267	if (ps->bigendian_data) {
	268	for (i = 0; i < len; i++)
	269	RSIVAL(q, 4*i, data32s[i]);
	270	} else {
	271	for (i = 0; i < len; i++)
	272	SIVAL(q, 4*i, data32s[i]);
	273	}
	274	}
	275
	276	ps->data_offset += (len * sizeof(uint32));
	277
	278	return true;
	279	}
	280
	281
	282	/*******************************************************************
	283	Stream a uint16.
	284	********************************************************************/
	285	bool prs_uint16(const char name, prs_struct ps, int depth, uint16 *data16)
	286	{
	287	char *q = prs_mem_get(ps, sizeof(uint16));
	288	if (q == NULL)
	289	return false;
	290
	291	if (ps->io) {
	292	if (ps->bigendian_data)
	293	*data16 = RSVAL(q,0);
	294	else
	295	*data16 = SVAL(q,0);
	296	} else {
	297	if (ps->bigendian_data)
	298	RSSVAL(q,0,*data16);
	299	else
	300	SSVAL(q,0,*data16);
	301	}
	302
	303
	304	ps->data_offset += sizeof(uint16);
	305
	306	return true;
	307	}
	308
	309
	310	/*******************************************************************
	311	prs_uint16 wrapper. Call this and it sets up a pointer to where the
	312	uint16 should be stored, or gets the size if reading.
	313	********************************************************************/
	314	bool prs_uint16_pre(const char name, prs_struct ps, int depth,
	315	uint16 data16, uint32 offset)
	316	{
	317	*offset = ps->data_offset;
	318	if (ps->io) {
	319	/* reading. */
	320	return prs_uint16(name, ps, depth, data16);
	321	} else {
	322	char *q = prs_mem_get(ps, sizeof(uint16));
	323	if(q ==NULL)
	324	return false;
	325	ps->data_offset += sizeof(uint16);
	326	}
	327	return true;
	328	}
	329
	330
	331	/*******************************************************************
	332	prs_uint16 wrapper. call this and it retrospectively stores the size.
	333	does nothing on reading, as that is already handled by ...._pre()
	334	********************************************************************/
	335	bool prs_uint16_post(const char name, prs_struct ps, int depth,
	336	uint16 *data16, uint32 ptr_uint16, uint32 start_offset)
	337	{
	338	if (!ps->io) {
	339	/*
	340	* Writing - temporarily move the offset pointer.
	341	*/
	342	uint16 data_size = ps->data_offset - start_offset;
	343	uint32 old_offset = ps->data_offset;
	344
	345	ps->data_offset = ptr_uint16;
	346	if(!prs_uint16(name, ps, depth, &data_size)) {
	347	ps->data_offset = old_offset;
	348	return false;
	349	}
	350	ps->data_offset = old_offset;
	351	} else {
	352	ps->data_offset = start_offset + (uint32)(*data16);
	353	}
	354	return true;
	355	}
	356
	357
	358	/*******************************************************************
	359	Stream a uint8.
	360	********************************************************************/
	361	bool prs_uint8(const char name, prs_struct ps, int depth, uint8 *data8)
	362	{
	363	char *q = prs_mem_get(ps, 1);
	364	if (q == NULL)
	365	return false;
	366
	367	if (ps->io)
	368	*data8 = CVAL(q,0);
	369	else
	370	SCVAL(q,0,*data8);
	371
	372	ps->data_offset += 1;
	373
	374	return true;
	375	}
	376
	377
	378	/******************************************************************
	379	Stream an array of uint8s. Length is number of uint8s.
	380	********************************************************************/
	381	bool prs_uint8s(bool charmode, const char name, prs_struct ps, int depth, uint8 *data8s, int len)
	382	{
	383	int i;
	384	char *q = prs_mem_get(ps, len);
	385	if (q == NULL)
	386	return false;
	387
	388	if (ps->io) {
	389	for (i = 0; i < len; i++)
	390	data8s[i] = CVAL(q,i);
	391	} else {
	392	for (i = 0; i < len; i++)
	393	SCVAL(q, i, data8s[i]);
	394	}
	395
	396	ps->data_offset += len;
	397
	398	return true;
	399	}
	400
	401
	402	/*******************************************************************
	403	Set the current offset (external interface).
	404	********************************************************************/
	405	bool prs_set_offset(prs_struct *ps, uint32 offset)
	406	{
	407	if(offset <= ps->data_offset) {
	408	ps->data_offset = offset;
	409	return true;
	410	}
	411
	412	if(!prs_grow(ps, offset - ps->data_offset))
	413	return false;
	414
	415	ps->data_offset = offset;
	416	return true;
	417	}
	418
	419	/* End of stuff from parse_prs.c */
	420
	421	/* From rpc_parse/parse_misc.c */
	422
	423	/*******************************************************************
	424	Reads or writes a struct uuid
	425	********************************************************************/
	426	bool smb_io_uuid(const char desc, struct uuid uuid,
	427	prs_struct *ps, int depth)
	428	{
	429	if (uuid == NULL)
	430	return false;
	431	depth++;
	432
	433	if(!prs_uint32 ("data ", ps, depth, &uuid->time_low))
	434	return false;
	435	if(!prs_uint16 ("data ", ps, depth, &uuid->time_mid))
	436	return false;
	437	if(!prs_uint16 ("data ", ps, depth, &uuid->time_hi_and_version))
	438	return false;
	439
	440	if(!prs_uint8s (false, "data ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq)))
	441	return false;
	442	if(!prs_uint8s (false, "data ", ps, depth, uuid->node, sizeof(uuid->node)))
	443	return false;
	444
	445	return true;
	446	}
	447
	448
	449	/*******************************************************************
	450	Reads or writes an NTTIME structure.
	451	********************************************************************/
	452	bool smb_io_time(const char desc, NTTIME nttime, prs_struct *ps, int depth)
	453	{
	454	if (nttime == NULL)
	455	return false;
	456	depth++;
	457
	458	if(!prs_align(ps))
	459	return false;
	460
	461	if(!prs_uint32("low ", ps, depth, &nttime->low)) /* low part */
	462	return false;
	463	if(!prs_uint32("high", ps, depth, &nttime->high)) /* high part */
	464	return false;
	465
	466	return true;
	467	}
	468
	469
	470	/*******************************************************************
	471	Reads or writes a DOM_SID structure.
	472	********************************************************************/
	473	bool smb_io_dom_sid(const char desc, DOM_SID sid, prs_struct *ps, int depth)
	474	{
	475	int i;
	476
	477	if (sid == NULL)
	478	return false;
	479	depth++;
	480
	481	if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
	482	return false;
	483
	484	if(!prs_uint8 ("num_auths ", ps, depth, &sid->num_auths))
	485	return false;
	486
	487	for (i = 0; i < 6; i++)
	488	{
	489	fstring tmp;
	490	snprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
	491	if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
	492	return false;
	493	}
	494
	495	/* oops! XXXX should really issue a warning here... */
	496	if (sid->num_auths > MAXSUBAUTHS)
	497	sid->num_auths = MAXSUBAUTHS;
	498
	499	if(!prs_uint32s(false, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
	500	return false;
	501
	502	return true;
	503	}
	504
	505	/* End of stuff from rpc_parse/parse_misc.c */
	506
	507	/* From lib/util_sid.c */
	508
	509	/*****************************************************************
	510	Calculates size of a sid.
	511	*****************************************************************/
	512	size_t sid_size(const DOM_SID *sid)
	513	{
	514	if (sid == NULL)
	515	return 0;
	516
	517	return sid->num_auths * sizeof(uint32) + 8;
	518	}
	519
	520
	521	/*****************************************************************
	522	Compare the auth portion of two sids.
	523	*****************************************************************/
[31]	524	int sid_compare_auth(const DOM_SID sid1, const DOM_SID sid2)
[30]	525	{
	526	int i;
	527
	528	if (sid1 == sid2)
	529	return 0;
	530	if (!sid1)
	531	return -1;
	532	if (!sid2)
	533	return 1;
	534
	535	if (sid1->sid_rev_num != sid2->sid_rev_num)
	536	return sid1->sid_rev_num - sid2->sid_rev_num;
	537
	538	for (i = 0; i < 6; i++)
	539	if (sid1->id_auth[i] != sid2->id_auth[i])
	540	return sid1->id_auth[i] - sid2->id_auth[i];
	541
	542	return 0;
	543	}
	544
	545
	546	/*****************************************************************
	547	Compare two sids.
	548	*****************************************************************/
	549	int sid_compare(const DOM_SID sid1, const DOM_SID sid2)
	550	{
	551	int i;
	552
	553	if (sid1 == sid2)
	554	return 0;
	555	if (!sid1)
	556	return -1;
	557	if (!sid2)
	558	return 1;
	559
	560	/* Compare most likely different rids, first: i.e start at end */
	561	if (sid1->num_auths != sid2->num_auths)
	562	return sid1->num_auths - sid2->num_auths;
	563
	564	for (i = sid1->num_auths-1; i >= 0; --i)
	565	if (sid1->sub_auths[i] != sid2->sub_auths[i])
	566	return sid1->sub_auths[i] - sid2->sub_auths[i];
	567
	568	return sid_compare_auth(sid1, sid2);
	569	}
	570
	571
	572	/*****************************************************************
	573	Compare two sids.
	574	*****************************************************************/
	575	bool sid_equal(const DOM_SID sid1, const DOM_SID sid2)
	576	{
	577	return sid_compare(sid1, sid2) == 0;
	578	}
	579
	580	/* End of stuff from lib/util_sid.c */
	581
	582	/* From lib/secace.c */
	583
	584	/*******************************************************************
	585	Check if ACE has OBJECT type.
	586	********************************************************************/
	587
	588	bool sec_ace_object(uint8 type)
	589	{
	590	if (type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT \|\|
	591	type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT \|\|
	592	type == SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT \|\|
	593	type == SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT) {
	594	return true;
	595	}
	596	return false;
	597	}
	598
	599	/* End of stuff from lib/secace.c */
	600
	601	/* From rpc_parse/parse_sec.c */
	602
	603	/*******************************************************************
	604	Reads or writes a SEC_ACCESS structure.
	605	********************************************************************/
	606	bool sec_io_access(const char desc, SEC_ACCESS t, prs_struct *ps, int depth)
	607	{
	608	if (t == NULL)
	609	return false;
	610
	611	depth++;
	612
	613	if(!prs_uint32("mask", ps, depth, &t->mask))
	614	return false;
	615
	616	return true;
	617	}
	618
	619
	620	/*******************************************************************
	621	Reads or writes a SEC_ACE structure.
	622	********************************************************************/
	623	bool sec_io_ace(const char desc, SEC_ACE psa, prs_struct *ps, int depth)
	624	{
	625	uint32 old_offset;
	626	uint32 offset_ace_size;
	627
	628	if (psa == NULL)
	629	return false;
	630
	631	depth++;
	632
	633	old_offset = ps->data_offset;
	634
	635	if(!prs_uint8("type ", ps, depth, &psa->type))
	636	return false;
	637
	638	if(!prs_uint8("flags", ps, depth, &psa->flags))
	639	return false;
	640
	641	if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
	642	return false;
	643
	644	if(!sec_io_access("info ", &psa->info, ps, depth))
	645	return false;
	646
	647	/* check whether object access is present */
	648	if (!sec_ace_object(psa->type)) {
	649	if (!smb_io_dom_sid("trustee ", &psa->trustee , ps, depth))
	650	return false;
	651	} else {
	652	if (!prs_uint32("obj_flags", ps, depth, &psa->obj_flags))
	653	return false;
	654
	655	if (psa->obj_flags & SEC_ACE_OBJECT_PRESENT)
	656	if (!smb_io_uuid("obj_guid", &psa->obj_guid, ps,depth))
	657	return false;
	658
	659	if (psa->obj_flags & SEC_ACE_OBJECT_INHERITED_PRESENT)
	660	if (!smb_io_uuid("inh_guid", &psa->inh_guid, ps,depth))
	661	return false;
	662
	663	if(!smb_io_dom_sid("trustee ", &psa->trustee , ps, depth))
	664	return false;
	665	}
	666
	667	/* Theorectically an ACE can have a size greater than the
	668	sum of its components. When marshalling, pad with extra null bytes up to the
	669	correct size. */
	670
	671	if (!ps->io && (psa->size > ps->data_offset - old_offset)) {
	672	uint32 extra_len = psa->size - (ps->data_offset - old_offset);
	673	uint32 i;
	674	uint8 c = 0;
	675
	676	for (i = 0; i < extra_len; i++) {
	677	if (!prs_uint8("ace extra space", ps, depth, &c))
	678	return false;
	679	}
	680	}
	681
	682	if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
	683	return false;
	684
	685	return true;
	686	}
	687
	688
	689	/*******************************************************************
	690	Reads or writes a SEC_ACL structure.
	691
	692	First of the xx_io_xx functions that allocates its data structures
	693	for you as it reads them.
	694	********************************************************************/
	695	bool sec_io_acl(const char desc, SEC_ACL ppsa, prs_struct ps, int depth)
	696	{
	697	unsigned int i;
	698	uint32 old_offset;
	699	uint32 offset_acl_size;
	700	SEC_ACL *psa;
	701
	702	/*
	703	* Note that the size is always a multiple of 4 bytes due to the
	704	* nature of the data structure. Therefore the prs_align() calls
	705	* have been removed as they through us off when doing two-layer
	706	* marshalling such as in the printing code (RPC_BUFFER). --jerry
	707	*/
	708
	709	if (ppsa == NULL)
	710	return false;
	711
	712	psa = *ppsa;
	713
	714	if(ps->io && psa == NULL) {
	715	/*
	716	* This is a read and we must allocate the stuct to read into.
	717	*/
	718	if((psa = (SEC_ACL*)zalloc(sizeof(SEC_ACL))) == NULL)
	719	return false;
	720	*ppsa = psa;
	721	}
	722
	723	depth++;
	724
	725	old_offset = ps->data_offset;
	726
	727	if(!prs_uint16("revision", ps, depth, &psa->revision))
	728	return false;
	729
	730	if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_acl_size))
	731	return false;
	732
	733	if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
	734	return false;
	735
	736	if (ps->io) {
	737	/*
	738	* Even if the num_aces is zero, allocate memory as there's a difference
	739	* between a non-present DACL (allow all access) and a DACL with no ACE's
	740	* (allow no access).
	741	*/
	742	if((psa->ace = (SEC_ACE*)zcalloc(sizeof(SEC_ACE), psa->num_aces+1)) == NULL)
	743	return false;
	744	}
	745
	746	for (i = 0; i < psa->num_aces; i++) {
	747	fstring tmp;
	748	snprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
	749	if(!sec_io_ace(tmp, &psa->ace[i], ps, depth))
	750	return false;
	751	}
	752
	753	/* Theorectically an ACL can have a size greater than the
	754	sum of its components. When marshalling, pad with extra null bytes up to the
	755	correct size. */
	756
	757	if (!ps->io && (psa->size > ps->data_offset - old_offset)) {
	758	uint32 extra_len = psa->size - (ps->data_offset - old_offset);
	759	uint8 c = 0;
	760
	761	for (i = 0; i < extra_len; i++) {
	762	if (!prs_uint8("acl extra space", ps, depth, &c))
	763	return false;
	764	}
	765	}
	766
	767	if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_acl_size, old_offset))
	768	return false;
	769
	770	return true;
	771	}
	772
	773
	774	/*******************************************************************
	775	Reads or writes a SEC_DESC structure.
	776	If reading and the *ppsd = NULL, allocates the structure.
	777	********************************************************************/
	778	bool sec_io_desc(const char desc, SEC_DESC ppsd, prs_struct ps, int depth)
	779	{
	780	uint32 old_offset;
	781	uint32 max_offset = 0; /* after we're done, move offset to end */
	782	uint32 tmp_offset = 0;
	783
	784	SEC_DESC *psd;
	785
	786	if (ppsd == NULL)
	787	return false;
	788
	789	psd = *ppsd;
	790
	791	if (psd == NULL) {
	792	if(ps->io) {
	793	if((psd = (SEC_DESC*)zalloc(sizeof(SEC_DESC))) == NULL)
	794	return false;
	795	*ppsd = psd;
	796	} else {
	797	/* Marshalling - just ignore. */
	798	return true;
	799	}
	800	}
	801
	802	depth++;
	803
	804	/* start of security descriptor stored for back-calc offset purposes */
	805	old_offset = ps->data_offset;
	806
	807	if(!prs_uint16("revision ", ps, depth, &psd->revision))
	808	return false;
	809
	810	if(!prs_uint16("type ", ps, depth, &psd->type))
	811	return false;
	812
	813	if (!ps->io) {
	814	uint32 offset = SEC_DESC_HEADER_SIZE;
	815
	816	/*
	817	* Work out the offsets here, as we write it out.
	818	*/
	819
	820	if (psd->sacl != NULL) {
	821	psd->off_sacl = offset;
	822	offset += psd->sacl->size;
	823	} else {
	824	psd->off_sacl = 0;
	825	}
	826
	827	if (psd->dacl != NULL) {
	828	psd->off_dacl = offset;
	829	offset += psd->dacl->size;
	830	} else {
	831	psd->off_dacl = 0;
	832	}
	833
	834	if (psd->owner_sid != NULL) {
	835	psd->off_owner_sid = offset;
	836	offset += sid_size(psd->owner_sid);
	837	} else {
	838	psd->off_owner_sid = 0;
	839	}
	840
	841	if (psd->grp_sid != NULL) {
	842	psd->off_grp_sid = offset;
	843	offset += sid_size(psd->grp_sid);
	844	} else {
	845	psd->off_grp_sid = 0;
	846	}
	847	}
	848
	849	if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
	850	return false;
	851
	852	if(!prs_uint32("off_grp_sid ", ps, depth, &psd->off_grp_sid))
	853	return false;
	854
	855	if(!prs_uint32("off_sacl ", ps, depth, &psd->off_sacl))
	856	return false;
	857
	858	if(!prs_uint32("off_dacl ", ps, depth, &psd->off_dacl))
	859	return false;
	860
	861	max_offset = MAX(max_offset, ps->data_offset);
	862
	863	if (psd->off_owner_sid != 0) {
	864
	865	tmp_offset = ps->data_offset;
	866	if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
	867	return false;
	868
	869	if (ps->io) {
	870	/* reading */
	871	if((psd->owner_sid = (DOM_SID*)zalloc(sizeof(DOM_SID))) == NULL)
	872	return false;
	873	}
	874
	875	if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
	876	return false;
	877
	878	max_offset = MAX(max_offset, ps->data_offset);
	879
	880	if (!prs_set_offset(ps,tmp_offset))
	881	return false;
	882	}
	883
	884	if (psd->off_grp_sid != 0) {
	885
	886	tmp_offset = ps->data_offset;
	887	if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
	888	return false;
	889
	890	if (ps->io) {
	891	/* reading */
	892	if((psd->grp_sid = (DOM_SID*)zalloc(sizeof(DOM_SID))) == NULL)
	893	return false;
	894	}
	895
	896	if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
	897	return false;
	898
	899	max_offset = MAX(max_offset, ps->data_offset);
	900
	901	if (!prs_set_offset(ps,tmp_offset))
	902	return false;
	903	}
	904
	905	if ((psd->type & SEC_DESC_SACL_PRESENT) && psd->off_sacl) {
	906	tmp_offset = ps->data_offset;
	907	if(!prs_set_offset(ps, old_offset + psd->off_sacl))
	908	return false;
	909	if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
	910	return false;
	911	max_offset = MAX(max_offset, ps->data_offset);
	912	if (!prs_set_offset(ps,tmp_offset))
	913	return false;
	914	}
	915
	916	if ((psd->type & SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) {
	917	tmp_offset = ps->data_offset;
	918	if(!prs_set_offset(ps, old_offset + psd->off_dacl))
	919	return false;
	920	if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
	921	return false;
	922	max_offset = MAX(max_offset, ps->data_offset);
	923	if (!prs_set_offset(ps,tmp_offset))
	924	return false;
	925	}
	926
	927	if(!prs_set_offset(ps, max_offset))
	928	return false;
	929
	930	return true;
	931	}
	932
	933	/* End of stuff from rpc_parse/parse_sec.c */
	934
	935	/* From lib/secace.c */
	936
	937	/*******************************************************************
	938	Compares two SEC_ACE structures
	939	********************************************************************/
	940	bool sec_ace_equal(SEC_ACE s1, SEC_ACE s2)
	941	{
	942	/* Trivial case */
	943
	944	if (!s1 && !s2) return true;
	945
	946	/* Check top level stuff */
	947
	948	if (s1->type != s2->type \|\| s1->flags != s2->flags \|\|
	949	s1->info.mask != s2->info.mask) {
	950	return false;
	951	}
	952
	953	/* Check SID */
	954
	955	if (!sid_equal(&s1->trustee, &s2->trustee)) {
	956	return false;
	957	}
	958
	959	return true;
	960	}
	961
	962	/* End of stuff from lib/secace.c */
	963
	964	/* From lib/secacl.c */
	965
	966	/*******************************************************************
	967	Compares two SEC_ACL structures
	968	********************************************************************/
	969
	970	bool sec_acl_equal(SEC_ACL s1, SEC_ACL s2)
	971	{
	972	unsigned int i, j;
	973
	974	/* Trivial cases */
	975
	976	if (!s1 && !s2) return true;
	977	if (!s1 \|\| !s2) return false;
	978
	979	/* Check top level stuff */
	980
	981	if (s1->revision != s2->revision) {
	982	return false;
	983	}
	984
	985	if (s1->num_aces != s2->num_aces) {
	986	return false;
	987	}
	988
	989	/* The ACEs could be in any order so check each ACE in s1 against
	990	each ACE in s2. */
	991
	992	for (i = 0; i < s1->num_aces; i++) {
	993	bool found = false;
	994
	995	for (j = 0; j < s2->num_aces; j++) {
	996	if (sec_ace_equal(&s1->ace[i], &s2->ace[j])) {
	997	found = true;
	998	break;
	999	}
	1000	}
	1001
	1002	if (!found) return false;
	1003	}
	1004
	1005	return true;
	1006	}
	1007
	1008	/* End of stuff from lib/secacl.c */
	1009
	1010	/* From lib/secdesc.c */
	1011
	1012	/*******************************************************************
	1013	Compares two SEC_DESC structures
	1014	********************************************************************/
	1015	bool sec_desc_equal(SEC_DESC s1, SEC_DESC s2)
	1016	{
	1017	/* Trivial case */
	1018
	1019	if (!s1 && !s2) {
	1020	goto done;
	1021	}
	1022
	1023	/* Check top level stuff */
	1024
	1025	if (s1->revision != s2->revision) {
	1026	return false;
	1027	}
	1028
	1029	if (s1->type!= s2->type) {
	1030	return false;
	1031	}
	1032
	1033	/* Check owner and group */
	1034
	1035	if (!sid_equal(s1->owner_sid, s2->owner_sid)) {
	1036	return false;
	1037	}
	1038
	1039	if (!sid_equal(s1->grp_sid, s2->grp_sid)) {
	1040	return false;
	1041	}
	1042
	1043	/* Check ACLs present in one but not the other */
	1044
	1045	if ((s1->dacl && !s2->dacl) \|\| (!s1->dacl && s2->dacl) \|\|
	1046	(s1->sacl && !s2->sacl) \|\| (!s1->sacl && s2->sacl))
	1047	{
	1048	return false;
	1049	}
	1050
	1051	/* Sigh - we have to do it the hard way by iterating over all
	1052	the ACEs in the ACLs */
	1053
	1054	if (!sec_acl_equal(s1->dacl, s2->dacl) \|\|
	1055	!sec_acl_equal(s1->sacl, s2->sacl))
	1056	{
	1057	return false;
	1058	}
	1059
	1060	done:
	1061	return true;
	1062	}
	1063
	1064	/* End of stuff from lib/secdesc.c */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: