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"
/*******************************************************************
Delete the memory in a parse structure - if we own it.
+
+ NOTE: Contrary to the somewhat confusing naming, this function is not
+ intended for freeing memory allocated by prs_alloc_mem(). That memory
+ is attached to the talloc context given by ps->mem_ctx.
********************************************************************/
void prs_mem_free(prs_struct *ps)
if (size && count) {
/* We can't call the type-safe version here. */
- ret = (char *)_talloc_zero_array_zeronull(ps->mem_ctx, size, count,
+ ret = (char *)_talloc_zero_array(ps->mem_ctx, size, count,
"parse_prs");
}
return ret;
return True;
if (UNMARSHALLING(ps)) {
- if ( !(*data = PRS_ALLOC_MEM(ps, char, data_size)) )
- return False;
+ if (data_size) {
+ if ( !(*data = PRS_ALLOC_MEM(ps, char, data_size)) )
+ return False;
+ } else {
+ *data = NULL;
+ }
}
return prs_fn(name, ps, depth, *data);
if (q == NULL)
return False;
+ /* If the string is empty, we don't have anything to stream */
+ if (str->buf_len==0)
+ return True;
+
if (UNMARSHALLING(ps)) {
str->buffer = PRS_ALLOC_MEM(ps,uint16,str->buf_len);
if (str->buffer == NULL)
return False;
}
- /* If the string is empty, we don't have anything to stream */
- if (str->buf_len==0)
- return True;
-
p = (char *)str->buffer;
dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len);
buf->buffer = PRS_ALLOC_MEM(ps, uint16, buf->buf_max_len);
if ( buf->buffer == NULL )
return False;
+ } else {
+ buf->buffer = NULL;
}
}
if (str->str_str_len > str->str_max_len) {
return False;
}
- str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
- if (str->buffer == NULL)
- return False;
+ if (str->str_max_len) {
+ str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
+ if (str->buffer == NULL)
+ return False;
+ } else {
+ str->buffer = NULL;
+ /* Return early to ensure Coverity isn't confused. */
+ DEBUG(5,("%s%04x %s: \n", tab_depth(depth), ps->data_offset, name));
+ return True;
+ }
}
if (UNMARSHALLING(ps)) {
if (str->uni_str_len > str->uni_max_len) {
return False;
}
- str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
- if (str->buffer == NULL)
- return False;
+ if (str->uni_max_len) {
+ str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
+ if (str->buffer == NULL)
+ return False;
+ } else {
+ str->buffer = NULL;
+ }
}
p = (char *)str->buffer;
return False;
if (UNMARSHALLING(ps)) {
- str->str.buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_str_len);
- if (str->str.buffer == NULL)
- return False;
+ if (str->uni_str_len) {
+ str->str.buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_str_len);
+ if (str->str.buffer == NULL)
+ return False;
+ } else {
+ str->str.buffer = NULL;
+ }
}
p = (char *)str->str.buffer;
return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
}
-int tdb_prs_store_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
-{
- TDB_DATA kbuf = string_term_tdb_data(keystr);
- return tdb_prs_store(tdb, kbuf, ps);
-}
-
/* useful function to fetch a structure into rpc wire format */
int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *mem_ctx)
{
prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
return 0;
-}
-
-int tdb_prs_fetch_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
-{
- TDB_DATA kbuf = string_term_tdb_data(keystr);
- return tdb_prs_fetch(tdb, kbuf, ps, mem_ctx);
}
/*******************************************************************
uchar digest_final[16])
{
uchar whole_packet_digest[16];
- static uchar zeros[4];
+ static const uchar zeros[4] = { 0, };
struct MD5Context ctx3;
/* verfiy the signature on the packet by MD5 over various bits */
RPC_AUTH_SCHANNEL_CHK *verf,
uchar sealing_key[16])
{
- static uchar zeros[4];
+ static const uchar zeros[4] = { 0, };
uchar digest2[16];
uchar sess_kf0[16];
int i;
static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
RPC_AUTH_SCHANNEL_CHK *verf)
{
- static uchar zeros[4];
+ static const uchar zeros[4] = { 0, };
uchar sequence_key[16];
uchar digest1[16];
checksum after the decode, below
*/
DEBUG(2, ("schannel_decode: FAILED: packet sequence number:\n"));
- dump_data(2, (const uint8 *)verf->seq_num, sizeof(verf->seq_num));
+ dump_data(2, verf->seq_num, sizeof(verf->seq_num));
DEBUG(2, ("should be:\n"));
- dump_data(2, (const uint8 *)seq_num, sizeof(seq_num));
+ dump_data(2, seq_num, sizeof(seq_num));
return False;
}
if (memcmp(verf->sig, schannel_sig, sizeof(verf->sig))) {
/* Validate that the other end sent the expected header */
DEBUG(2, ("schannel_decode: FAILED: packet header:\n"));
- dump_data(2, (const uint8 *)verf->sig, sizeof(verf->sig));
+ dump_data(2, verf->sig, sizeof(verf->sig));
DEBUG(2, ("should be:\n"));
- dump_data(2, (const uint8 *)schannel_sig, sizeof(schannel_sig));
+ dump_data(2, schannel_sig, sizeof(schannel_sig));
return False;
}
git.samba.org / samba.git / blobdiff