RIP BOOL. Convert BOOL -> bool. I found a few interesting

[samba.git] / source3 / rpc_parse / parse_prs.c

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b22b1faa3fba6ca4a6dec3c9978662af74870c2a..a30e96772a0b45df5a7789052a1ac4465e8f3e92 100644 (file)
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -92,7 +92,7 @@ void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
  * @return False if allocation fails, otherwise True.
  **/
 
-BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
+bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io)
 {
        ZERO_STRUCTP(ps);
        ps->io = io;
@@ -180,7 +180,7 @@ TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
  Hand some already allocated memory to a prs_struct.
  ********************************************************************/
 
-void prs_give_memory(prs_struct *ps, char *buf, uint32 size, BOOL is_dynamic)
+void prs_give_memory(prs_struct *ps, char *buf, uint32 size, bool is_dynamic)
 {
        ps->is_dynamic = is_dynamic;
        ps->data_p = buf;
@@ -205,7 +205,7 @@ char *prs_take_memory(prs_struct *ps, uint32 *psize)
  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)
+bool prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 {
        if (newsize > ps->buffer_size)
                return prs_force_grow(ps, newsize - ps->buffer_size);
@@ -236,7 +236,7 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
  Also depends on the data stream mode (io).
  ********************************************************************/
 
-BOOL prs_grow(prs_struct *ps, uint32 extra_space)
+bool prs_grow(prs_struct *ps, uint32 extra_space)
 {
        uint32 new_size;
 
@@ -300,7 +300,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
  when reading an rpc reply, before unmarshalling it.
  ********************************************************************/
 
-BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
+bool prs_force_grow(prs_struct *ps, uint32 extra_space)
 {
        uint32 new_size = ps->buffer_size + extra_space;
 
@@ -354,7 +354,7 @@ uint32 prs_offset(prs_struct *ps)
  Set the current offset (external interface).
  ********************************************************************/
 
-BOOL prs_set_offset(prs_struct *ps, uint32 offset)
+bool prs_set_offset(prs_struct *ps, uint32 offset)
 {
        if(offset <= ps->data_offset) {
                ps->data_offset = offset;
@@ -372,7 +372,7 @@ BOOL prs_set_offset(prs_struct *ps, uint32 offset)
  Append the data from one parse_struct into another.
  ********************************************************************/
 
-BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
+bool prs_append_prs_data(prs_struct *dst, prs_struct *src)
 {
        if (prs_offset(src) == 0)
                return True;
@@ -390,7 +390,7 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
  Append some data from one parse_struct into another.
  ********************************************************************/
 
-BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
+bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 {      
        if (len == 0)
                return True;
@@ -408,7 +408,7 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
  Append the data from a buffer into a parse_struct.
  ********************************************************************/
 
-BOOL prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
+bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
 {
        if (len == 0)
                return True;
@@ -426,7 +426,7 @@ BOOL prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
  Copy some data from a parse_struct into a buffer.
  ********************************************************************/
 
-BOOL prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
+bool prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
 {
        if (len == 0)
                return True;
@@ -444,7 +444,7 @@ BOOL prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
  Copy all the data from a parse_struct into a buffer.
  ********************************************************************/
 
-BOOL prs_copy_all_data_out(char *dst, prs_struct *src)
+bool prs_copy_all_data_out(char *dst, prs_struct *src)
 {
        uint32 len = prs_offset(src);
 
@@ -459,7 +459,7 @@ BOOL prs_copy_all_data_out(char *dst, prs_struct *src)
  Set the data as X-endian (external interface).
  ********************************************************************/
 
-void prs_set_endian_data(prs_struct *ps, BOOL endian)
+void prs_set_endian_data(prs_struct *ps, bool endian)
 {
        ps->bigendian_data = endian;
 }
@@ -469,7 +469,7 @@ void prs_set_endian_data(prs_struct *ps, BOOL endian)
  zeros.
  ********************************************************************/
 
-BOOL prs_align(prs_struct *ps)
+bool prs_align(prs_struct *ps)
 {
        uint32 mod = ps->data_offset & (ps->align-1);
 
@@ -488,9 +488,9 @@ BOOL prs_align(prs_struct *ps)
  Align on a 2 byte boundary
  *****************************************************************/
  
-BOOL prs_align_uint16(prs_struct *ps)
+bool prs_align_uint16(prs_struct *ps)
 {
-       BOOL ret;
+       bool ret;
        uint8 old_align = ps->align;
 
        ps->align = 2;
@@ -504,9 +504,9 @@ BOOL prs_align_uint16(prs_struct *ps)
  Align on a 8 byte boundary
  *****************************************************************/
  
-BOOL prs_align_uint64(prs_struct *ps)
+bool prs_align_uint64(prs_struct *ps)
 {
-       BOOL ret;
+       bool ret;
        uint8 old_align = ps->align;
 
        ps->align = 8;
@@ -520,9 +520,9 @@ BOOL prs_align_uint64(prs_struct *ps)
  Align on a specific byte boundary
  *****************************************************************/
  
-BOOL prs_align_custom(prs_struct *ps, uint8 boundary)
+bool prs_align_custom(prs_struct *ps, uint8 boundary)
 {
-       BOOL ret;
+       bool ret;
        uint8 old_align = ps->align;
 
        ps->align = boundary;
@@ -538,7 +538,7 @@ BOOL prs_align_custom(prs_struct *ps, uint8 boundary)
  Align only if required (for the unistr2 string mainly)
  ********************************************************************/
 
-BOOL prs_align_needed(prs_struct *ps, uint32 needed)
+bool prs_align_needed(prs_struct *ps, uint32 needed)
 {
        if (needed==0)
                return True;
@@ -577,7 +577,7 @@ char *prs_mem_get(prs_struct *ps, uint32 extra_size)
  Change the struct type.
  ********************************************************************/
 
-void prs_switch_type(prs_struct *ps, BOOL io)
+void prs_switch_type(prs_struct *ps, bool io)
 {
        if ((ps->io ^ io) == True)
                ps->io=io;
@@ -605,7 +605,7 @@ void prs_set_session_key(prs_struct *ps, const char sess_key[16])
  Stream a uint8.
  ********************************************************************/
 
-BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
+bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 {
        char *q = prs_mem_get(ps, 1);
        if (q == NULL)
@@ -627,9 +627,9 @@ BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
  Stream a uint16* (allocate memory if unmarshalling)
  ********************************************************************/
 
-BOOL prs_pointer( const char *name, prs_struct *ps, int depth, 
+bool prs_pointer( const char *name, prs_struct *ps, int depth, 
                  void *dta, size_t data_size,
-                 BOOL(*prs_fn)(const char*, prs_struct*, int, void*) )
+                 bool (*prs_fn)(const char*, prs_struct*, int, void*) )
 {
        void ** data = (void **)dta;
        uint32 data_p;
@@ -663,7 +663,7 @@ BOOL prs_pointer( const char *name, prs_struct *ps, int depth,
  Stream a uint16.
  ********************************************************************/
 
-BOOL prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
+bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
 {
        char *q = prs_mem_get(ps, sizeof(uint16));
        if (q == NULL)
@@ -692,7 +692,7 @@ BOOL prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
  Stream a uint32.
  ********************************************************************/
 
-BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
+bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 {
        char *q = prs_mem_get(ps, sizeof(uint32));
        if (q == NULL)
@@ -721,7 +721,7 @@ BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
  Stream an int32.
  ********************************************************************/
 
-BOOL prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
+bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
 {
        char *q = prs_mem_get(ps, sizeof(int32));
        if (q == NULL)
@@ -750,7 +750,7 @@ BOOL prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
  Stream a NTSTATUS
  ********************************************************************/
 
-BOOL prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
+bool prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
 {
        char *q = prs_mem_get(ps, sizeof(uint32));
        if (q == NULL)
@@ -780,7 +780,7 @@ BOOL prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
  Stream a DCE error code
  ********************************************************************/
 
-BOOL prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
+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)
@@ -811,7 +811,7 @@ BOOL prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *st
  Stream a WERROR
  ********************************************************************/
 
-BOOL prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
+bool prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
 {
        char *q = prs_mem_get(ps, sizeof(uint32));
        if (q == NULL)
@@ -842,7 +842,7 @@ BOOL prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
  Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
 
-BOOL prs_uint8s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
        int i;
        char *q = prs_mem_get(ps, len);
@@ -875,7 +875,7 @@ BOOL prs_uint8s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint
  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)
+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));
@@ -919,7 +919,7 @@ BOOL prs_uint16s(BOOL charmode, const char *name, prs_struct *ps, int depth, uin
  output must be little-endian, if marshalling, input must be little-endian.
  ********************************************************************/
 
-static void dbg_rw_punival(BOOL charmode, const char *name, int depth, prs_struct *ps,
+static void dbg_rw_punival(bool charmode, const char *name, int depth, prs_struct *ps,
                                                        char *in_buf, char *out_buf, int len)
 {
        int i;
@@ -956,7 +956,7 @@ static void dbg_rw_punival(BOOL charmode, const char *name, int depth, prs_struc
  Stream a unistr. Always little endian.
  ********************************************************************/
 
-BOOL prs_uint16uni(BOOL charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+bool prs_uint16uni(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
        char *q = prs_mem_get(ps, len * sizeof(uint16));
        if (q == NULL)
@@ -972,7 +972,7 @@ BOOL prs_uint16uni(BOOL charmode, const char *name, prs_struct *ps, int depth, u
  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)
+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));
@@ -1016,7 +1016,7 @@ BOOL prs_uint32s(BOOL charmode, const char *name, prs_struct *ps, int depth, uin
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUFFER5 *str)
+bool prs_buffer5(bool charmode, const char *name, prs_struct *ps, int depth, BUFFER5 *str)
 {
        char *p;
        char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
@@ -1047,7 +1047,7 @@ BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
  in byte chars. String is in little-endian format.
  ********************************************************************/
 
-BOOL prs_regval_buffer(BOOL charmode, const char *name, prs_struct *ps, int depth, REGVAL_BUFFER *buf)
+bool prs_regval_buffer(bool charmode, const char *name, prs_struct *ps, int depth, REGVAL_BUFFER *buf)
 {
        char *p;
        char *q = prs_mem_get(ps, buf->buf_len);
@@ -1080,7 +1080,7 @@ BOOL prs_regval_buffer(BOOL charmode, const char *name, prs_struct *ps, int dept
  in uint8 chars.
  ********************************************************************/
 
-BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
+bool prs_string2(bool charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
 {
        unsigned int i;
        char *q = prs_mem_get(ps, str->str_str_len);
@@ -1130,7 +1130,7 @@ BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STR
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNISTR2 *str)
+bool prs_unistr2(bool charmode, const char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
        char *p;
        char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
@@ -1168,7 +1168,7 @@ BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNI
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps, int depth)
+bool prs_unistr3(bool charmode, const char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
        char *p;
        char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
@@ -1198,7 +1198,7 @@ BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps,
  in little-endian format then do it as a stream of bytes.
  ********************************************************************/
 
-BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
+bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 {
        unsigned int len = 0;
        unsigned char *p = (unsigned char *)str->buffer;
@@ -1323,7 +1323,7 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
  not include the null-termination character.
  ********************************************************************/
 
-BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
+bool prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
 {
        char *q;
        int i;
@@ -1361,7 +1361,7 @@ BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_
        return True;
 }
 
-BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **str)
+bool prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **str)
 {
        size_t len;
        char *tmp_str;
@@ -1395,7 +1395,7 @@ BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **
  uint16 should be stored, or gets the size if reading.
  ********************************************************************/
 
-BOOL prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
+bool prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
        *offset = ps->data_offset;
        if (UNMARSHALLING(ps)) {
@@ -1415,7 +1415,7 @@ BOOL prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16,
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 
-BOOL prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16,
+bool prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16,
                                uint32 ptr_uint16, uint32 start_offset)
 {
        if (MARSHALLING(ps)) {
@@ -1442,7 +1442,7 @@ BOOL prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16
  uint32 should be stored, or gets the size if reading.
  ********************************************************************/
 
-BOOL prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+bool prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
        *offset = ps->data_offset;
        if (UNMARSHALLING(ps) && (data32 != NULL)) {
@@ -1459,7 +1459,7 @@ BOOL prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32,
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 
-BOOL prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32,
+bool prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32,
                                uint32 ptr_uint32, uint32 data_size)
 {
        if (MARSHALLING(ps)) {
@@ -1506,7 +1506,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *m
  hash a stream.
  ********************************************************************/
 
-BOOL prs_hash1(prs_struct *ps, uint32 offset, int len)
+bool prs_hash1(prs_struct *ps, uint32 offset, int len)
 {
        char *q;
 
@@ -1615,7 +1615,7 @@ static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
 creates an RPC_AUTH_SCHANNEL_CHK structure.
 ********************************************************************/
 
-static BOOL init_rpc_auth_schannel_chk(RPC_AUTH_SCHANNEL_CHK * chk,
+static bool init_rpc_auth_schannel_chk(RPC_AUTH_SCHANNEL_CHK * chk,
                              const uchar sig[8],
                              const uchar packet_digest[8],
                              const uchar seq_num[8], const uchar confounder[8])
@@ -1717,7 +1717,7 @@ void schannel_encode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
  as well as decode sealed messages
  ********************************************************************/
 
-BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
+bool schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
                   enum schannel_direction direction, 
                   RPC_AUTH_SCHANNEL_CHK * verf, char *data, size_t data_len)
 {
@@ -1819,7 +1819,7 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 /*******************************************************************
 creates a new prs_struct containing a DATA_BLOB
 ********************************************************************/
-BOOL prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+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;
@@ -1834,7 +1834,7 @@ BOOL prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 /*******************************************************************
 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)
+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);