BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
{
if(!prs_grow(dst, len))
return False;
memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
dst->data_offset += len;
return True;
}
BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
{
if(!prs_grow(dst, prs_offset(src)))
return False;
memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
dst->data_offset += prs_offset(src);
return True;
}
bool prs_set_offset(prs_struct *ps, uint32_t offset)
{
if ((offset > ps->data_offset)
&& !prs_grow(ps, offset - ps->data_offset)) {
return False;
}
ps->data_offset = offset;
return True;
}
BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
{
if (len == 0)
return True;
if(!prs_grow(dst, len))
return False;
memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
dst->data_offset += len;
return True;
}
BOOL prs_set_offset(prs_struct *ps, uint32 offset)
{
if(offset <= ps->data_offset) {
ps->data_offset = offset;
return True;
}
if(!prs_grow(ps, offset - ps->data_offset))
return False;
ps->data_offset = offset;
return True;
}
bool prs_copy_data_in(prs_struct *dst, const char *src, uint32_t len)
{
if (len == 0)
return True;
if(!prs_grow(dst, len))
return False;
memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
dst->data_offset += len;
return True;
}
BOOL prs_align(prs_struct *ps)
{
uint32 mod = ps->data_offset & (ps->align-1);
if (ps->align != 0 && mod != 0) {
uint32 extra_space = (ps->align - mod);
if(!prs_grow(ps, extra_space))
return False;
memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
ps->data_offset += extra_space;
}
return True;
}
/*******************************************************************
read from a socket into memory.
********************************************************************/
BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
{
BOOL ok;
size_t prev_size = ps->buffer_size;
if (!prs_grow(ps, len))
return False;
if (timeout > 0) {
ok = (read_with_timeout(fd, &ps->data_p[prev_size],
len, len,timeout) == len);
} else {
ok = (read_data(fd, &ps->data_p[prev_size], len) == len);
}
return ok;
}
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;
}
char *prs_mem_get(prs_struct *ps, uint32 extra_size)
{
if(UNMARSHALLING(ps)) {
/*
* If reading, ensure that we can read the requested size item.
*/
if (ps->data_offset + extra_size > ps->buffer_size) {
DEBUG(0,("prs_mem_get: reading data of size %u would overrun buffer.\n",
(unsigned int)extra_size ));
return NULL;
}
} else {
/*
* Writing - grow the buffer if needed.
*/
if(!prs_grow(ps, extra_size))
return NULL;
}
return &ps->data_p[ps->data_offset];
}
BOOL rpcbuf_alloc_size(RPC_BUFFER *buffer, uint32 buffer_size)
{
prs_struct *ps;
uint32 extra_space;
uint32 old_offset;
/* if we don't need anything. don't do anything */
if ( buffer_size == 0x0 )
return True;
if (!buffer) {
return False;
}
ps= &buffer->prs;
/* damn, I'm doing the reverse operation of prs_grow() :) */
if (buffer_size < prs_data_size(ps))
extra_space=0;
else
extra_space = buffer_size - prs_data_size(ps);
/*
* save the offset and move to the end of the buffer
* prs_grow() checks the extra_space against the offset
*/
old_offset=prs_offset(ps);
prs_set_offset(ps, prs_data_size(ps));
if (!prs_grow(ps, extra_space))
return False;
prs_set_offset(ps, old_offset);
buffer->string_at_end=prs_data_size(ps);
return True;
}