mirror of
https://github.com/samba-team/samba.git
synced 2024-12-23 17:34:34 +03:00
rep_parse_prs: remove some dead, unused code.
Guenther
This commit is contained in:
Günther Deschner
parent
c109a70531
commit
5fcb4d328c
@ -97,16 +97,6 @@ void prs_mem_free(prs_struct *ps)
|
||||
ps->data_offset = 0;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Clear the memory in a parse structure.
|
||||
********************************************************************/
|
||||
|
||||
void prs_mem_clear(prs_struct *ps)
|
||||
{
|
||||
if (ps->buffer_size)
|
||||
memset(ps->data_p, '\0', (size_t)ps->buffer_size);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Allocate memory when unmarshalling... Always zero clears.
|
||||
********************************************************************/
|
||||
@ -136,55 +126,6 @@ TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
|
||||
return ps->mem_ctx;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Hand some already allocated memory to a prs_struct.
|
||||
If "is_dynamic" is true, this is a talloc_steal.
|
||||
If "is_dynamic" is false, just make ps->data_p a pointer to
|
||||
the unwritable memory.
|
||||
********************************************************************/
|
||||
|
||||
void prs_give_memory(prs_struct *ps, char *buf, uint32 size, bool is_dynamic)
|
||||
{
|
||||
ps->is_dynamic = is_dynamic;
|
||||
if (ps->is_dynamic && buf) {
|
||||
talloc_steal(ps->mem_ctx, buf);
|
||||
}
|
||||
ps->data_p = buf;
|
||||
ps->buffer_size = size;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Set a prs_struct to exactly a given size. Will grow or tuncate if neccessary.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_set_buffer_size(prs_struct *ps, uint32 newsize)
|
||||
{
|
||||
if (newsize > ps->buffer_size)
|
||||
return prs_force_grow(ps, newsize - ps->buffer_size);
|
||||
|
||||
if (newsize < ps->buffer_size) {
|
||||
ps->buffer_size = newsize;
|
||||
|
||||
/* newsize == 0 acts as a free and set pointer to NULL */
|
||||
if (newsize == 0) {
|
||||
TALLOC_FREE(ps->data_p);
|
||||
} else {
|
||||
ps->data_p = talloc_realloc(ps->mem_ctx,
|
||||
ps->data_p,
|
||||
char,
|
||||
newsize);
|
||||
|
||||
if (ps->data_p == NULL) {
|
||||
DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
|
||||
(unsigned int)newsize));
|
||||
return False;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Attempt, if needed, to grow a data buffer.
|
||||
Also depends on the data stream mode (io).
|
||||
@ -255,39 +196,6 @@ bool prs_grow(prs_struct *ps, uint32 extra_space)
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Attempt to force a data buffer to grow by len bytes.
|
||||
This is only used when appending more data onto a prs_struct
|
||||
when reading an rpc reply, before unmarshalling it.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_force_grow(prs_struct *ps, uint32 extra_space)
|
||||
{
|
||||
uint32 new_size = ps->buffer_size + extra_space;
|
||||
|
||||
if(!UNMARSHALLING(ps) || !ps->is_dynamic) {
|
||||
DEBUG(0,("prs_force_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
|
||||
(unsigned int)extra_space));
|
||||
return False;
|
||||
}
|
||||
|
||||
ps->data_p = (char *)talloc_realloc(ps->mem_ctx,
|
||||
ps->data_p,
|
||||
char,
|
||||
new_size);
|
||||
if(ps->data_p == NULL) {
|
||||
DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
|
||||
(unsigned int)new_size));
|
||||
return False;
|
||||
}
|
||||
|
||||
memset(&ps->data_p[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
|
||||
|
||||
ps->buffer_size = new_size;
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Get the data pointer (external interface).
|
||||
********************************************************************/
|
||||
@ -330,50 +238,6 @@ bool prs_set_offset(prs_struct *ps, uint32 offset)
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Append the data from one parse_struct into another.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_append_prs_data(prs_struct *dst, prs_struct *src)
|
||||
{
|
||||
if (prs_offset(src) == 0)
|
||||
return True;
|
||||
|
||||
if(!prs_grow(dst, prs_offset(src)))
|
||||
return False;
|
||||
|
||||
memcpy(&dst->data_p[dst->data_offset], src->data_p, (size_t)prs_offset(src));
|
||||
dst->data_offset += prs_offset(src);
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Append some data from one parse_struct into another.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_append_some_data(prs_struct *dst, void *src_base, uint32_t start,
|
||||
uint32_t len)
|
||||
{
|
||||
if (len == 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if(!prs_grow(dst, len)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(&dst->data_p[dst->data_offset], ((char *)src_base) + start, (size_t)len);
|
||||
dst->data_offset += len;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start,
|
||||
uint32 len)
|
||||
{
|
||||
return prs_append_some_data(dst, src->data_p, start, len);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Append the data from a buffer into a parse_struct.
|
||||
********************************************************************/
|
||||
@ -392,48 +256,6 @@ bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Copy some data from a parse_struct into a buffer.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
|
||||
{
|
||||
if (len == 0)
|
||||
return True;
|
||||
|
||||
if(!prs_mem_get(src, len))
|
||||
return False;
|
||||
|
||||
memcpy(dst, &src->data_p[src->data_offset], (size_t)len);
|
||||
src->data_offset += len;
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Copy all the data from a parse_struct into a buffer.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_copy_all_data_out(char *dst, prs_struct *src)
|
||||
{
|
||||
uint32 len = prs_offset(src);
|
||||
|
||||
if (!len)
|
||||
return True;
|
||||
|
||||
prs_set_offset(src, 0);
|
||||
return prs_copy_data_out(dst, src, len);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Set the data as X-endian (external interface).
|
||||
********************************************************************/
|
||||
|
||||
void prs_set_endian_data(prs_struct *ps, bool endian)
|
||||
{
|
||||
ps->bigendian_data = endian;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Align a the data_len to a multiple of align bytes - filling with
|
||||
zeros.
|
||||
@ -454,22 +276,6 @@ bool prs_align(prs_struct *ps)
|
||||
return True;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
Align on a 2 byte boundary
|
||||
*****************************************************************/
|
||||
|
||||
bool prs_align_uint16(prs_struct *ps)
|
||||
{
|
||||
bool ret;
|
||||
uint8 old_align = ps->align;
|
||||
|
||||
ps->align = 2;
|
||||
ret = prs_align(ps);
|
||||
ps->align = old_align;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
Align on a 8 byte boundary
|
||||
*****************************************************************/
|
||||
@ -486,36 +292,6 @@ bool prs_align_uint64(prs_struct *ps)
|
||||
return ret;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
Align on a specific byte boundary
|
||||
*****************************************************************/
|
||||
|
||||
bool prs_align_custom(prs_struct *ps, uint8 boundary)
|
||||
{
|
||||
bool ret;
|
||||
uint8 old_align = ps->align;
|
||||
|
||||
ps->align = boundary;
|
||||
ret = prs_align(ps);
|
||||
ps->align = old_align;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
Align only if required (for the unistr2 string mainly)
|
||||
********************************************************************/
|
||||
|
||||
bool prs_align_needed(prs_struct *ps, uint32 needed)
|
||||
{
|
||||
if (needed==0)
|
||||
return True;
|
||||
else
|
||||
return prs_align(ps);
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Ensure we can read/write to a given offset.
|
||||
********************************************************************/
|
||||
@ -633,35 +409,6 @@ bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Stream an int32.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
|
||||
{
|
||||
char *q = prs_mem_get(ps, sizeof(int32));
|
||||
if (q == NULL)
|
||||
return False;
|
||||
|
||||
if (UNMARSHALLING(ps)) {
|
||||
if (ps->bigendian_data)
|
||||
*data32 = RIVALS(q,0);
|
||||
else
|
||||
*data32 = IVALS(q,0);
|
||||
} else {
|
||||
if (ps->bigendian_data)
|
||||
RSIVALS(q,0,*data32);
|
||||
else
|
||||
SIVALS(q,0,*data32);
|
||||
}
|
||||
|
||||
DEBUGADD(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
|
||||
|
||||
ps->data_offset += sizeof(int32);
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Stream a uint64_struct
|
||||
********************************************************************/
|
||||
@ -686,36 +433,6 @@ bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64)
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
Stream a DCE error code
|
||||
********************************************************************/
|
||||
|
||||
bool prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
|
||||
{
|
||||
char *q = prs_mem_get(ps, sizeof(uint32));
|
||||
if (q == NULL)
|
||||
return False;
|
||||
|
||||
if (UNMARSHALLING(ps)) {
|
||||
if (ps->bigendian_data)
|
||||
*status = NT_STATUS(RIVAL(q,0));
|
||||
else
|
||||
*status = NT_STATUS(IVAL(q,0));
|
||||
} else {
|
||||
if (ps->bigendian_data)
|
||||
RSIVAL(q,0,NT_STATUS_V(*status));
|
||||
else
|
||||
SIVAL(q,0,NT_STATUS_V(*status));
|
||||
}
|
||||
|
||||
DEBUGADD(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name,
|
||||
dcerpc_errstr(talloc_tos(), NT_STATUS_V(*status))));
|
||||
|
||||
ps->data_offset += sizeof(uint32);
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
Stream an array of uint8s. Length is number of uint8s.
|
||||
********************************************************************/
|
||||
@ -748,121 +465,3 @@ bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
Stream an array of uint16s. Length is number of uint16s.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_uint16s(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
|
||||
{
|
||||
int i;
|
||||
char *q = prs_mem_get(ps, len * sizeof(uint16));
|
||||
if (q == NULL)
|
||||
return False;
|
||||
|
||||
if (UNMARSHALLING(ps)) {
|
||||
if (ps->bigendian_data) {
|
||||
for (i = 0; i < len; i++)
|
||||
data16s[i] = RSVAL(q, 2*i);
|
||||
} else {
|
||||
for (i = 0; i < len; i++)
|
||||
data16s[i] = SVAL(q, 2*i);
|
||||
}
|
||||
} else {
|
||||
if (ps->bigendian_data) {
|
||||
for (i = 0; i < len; i++)
|
||||
RSSVAL(q, 2*i, data16s[i]);
|
||||
} else {
|
||||
for (i = 0; i < len; i++)
|
||||
SSVAL(q, 2*i, data16s[i]);
|
||||
}
|
||||
}
|
||||
|
||||
DEBUGADD(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
|
||||
if (charmode)
|
||||
print_asc(5, (unsigned char*)data16s, 2*len);
|
||||
else {
|
||||
for (i = 0; i < len; i++)
|
||||
DEBUGADD(5,("%04x ", data16s[i]));
|
||||
}
|
||||
DEBUGADD(5,("\n"));
|
||||
|
||||
ps->data_offset += (len * sizeof(uint16));
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
Stream an array of uint32s. Length is number of uint32s.
|
||||
********************************************************************/
|
||||
|
||||
bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
|
||||
{
|
||||
int i;
|
||||
char *q = prs_mem_get(ps, len * sizeof(uint32));
|
||||
if (q == NULL)
|
||||
return False;
|
||||
|
||||
if (UNMARSHALLING(ps)) {
|
||||
if (ps->bigendian_data) {
|
||||
for (i = 0; i < len; i++)
|
||||
data32s[i] = RIVAL(q, 4*i);
|
||||
} else {
|
||||
for (i = 0; i < len; i++)
|
||||
data32s[i] = IVAL(q, 4*i);
|
||||
}
|
||||
} else {
|
||||
if (ps->bigendian_data) {
|
||||
for (i = 0; i < len; i++)
|
||||
RSIVAL(q, 4*i, data32s[i]);
|
||||
} else {
|
||||
for (i = 0; i < len; i++)
|
||||
SIVAL(q, 4*i, data32s[i]);
|
||||
}
|
||||
}
|
||||
|
||||
DEBUGADD(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
|
||||
if (charmode)
|
||||
print_asc(5, (unsigned char*)data32s, 4*len);
|
||||
else {
|
||||
for (i = 0; i < len; i++)
|
||||
DEBUGADD(5,("%08x ", data32s[i]));
|
||||
}
|
||||
DEBUGADD(5,("\n"));
|
||||
|
||||
ps->data_offset += (len * sizeof(uint32));
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
creates a new prs_struct containing a DATA_BLOB
|
||||
********************************************************************/
|
||||
bool prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
|
||||
{
|
||||
if (!prs_init( prs, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL ))
|
||||
return False;
|
||||
|
||||
|
||||
if (!prs_copy_data_in(prs, (char *)blob->data, blob->length))
|
||||
return False;
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
return the contents of a prs_struct in a DATA_BLOB
|
||||
********************************************************************/
|
||||
bool prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
|
||||
{
|
||||
blob->length = prs_data_size(prs);
|
||||
blob->data = (uint8 *)TALLOC_ZERO_SIZE(mem_ctx, blob->length);
|
||||
|
||||
/* set the pointer at the end of the buffer */
|
||||
prs_set_offset( prs, prs_data_size(prs) );
|
||||
|
||||
if (!prs_copy_all_data_out((char *)blob->data, prs))
|
||||
return False;
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
@ -59,43 +59,23 @@ typedef struct _prs_struct {
|
||||
void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name);
|
||||
bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io);
|
||||
void prs_mem_free(prs_struct *ps);
|
||||
void prs_mem_clear(prs_struct *ps);
|
||||
char *prs_alloc_mem_(prs_struct *ps, size_t size, unsigned int count);
|
||||
char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count);
|
||||
TALLOC_CTX *prs_get_mem_context(prs_struct *ps);
|
||||
void prs_give_memory(prs_struct *ps, char *buf, uint32 size, bool is_dynamic);
|
||||
bool prs_set_buffer_size(prs_struct *ps, uint32 newsize);
|
||||
bool prs_grow(prs_struct *ps, uint32 extra_space);
|
||||
bool prs_force_grow(prs_struct *ps, uint32 extra_space);
|
||||
char *prs_data_p(prs_struct *ps);
|
||||
uint32 prs_data_size(prs_struct *ps);
|
||||
uint32 prs_offset(prs_struct *ps);
|
||||
bool prs_set_offset(prs_struct *ps, uint32 offset);
|
||||
bool prs_append_prs_data(prs_struct *dst, prs_struct *src);
|
||||
bool prs_append_some_data(prs_struct *dst, void *src_base, uint32_t start,
|
||||
uint32_t len);
|
||||
bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len);
|
||||
bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len);
|
||||
bool prs_copy_data_out(char *dst, prs_struct *src, uint32 len);
|
||||
bool prs_copy_all_data_out(char *dst, prs_struct *src);
|
||||
void prs_set_endian_data(prs_struct *ps, bool endian);
|
||||
bool prs_align(prs_struct *ps);
|
||||
bool prs_align_uint16(prs_struct *ps);
|
||||
bool prs_align_uint64(prs_struct *ps);
|
||||
bool prs_align_custom(prs_struct *ps, uint8 boundary);
|
||||
bool prs_align_needed(prs_struct *ps, uint32 needed);
|
||||
char *prs_mem_get(prs_struct *ps, uint32 extra_size);
|
||||
void prs_switch_type(prs_struct *ps, bool io);
|
||||
bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8);
|
||||
bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16);
|
||||
bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32);
|
||||
bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32);
|
||||
bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64);
|
||||
bool prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status);
|
||||
bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len);
|
||||
bool prs_uint16s(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len);
|
||||
bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len);
|
||||
bool prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
|
||||
bool prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue
Block a user