r4088: Get medieval on our ass about malloc.... :-). Take control of all our allocation
authorJeremy Allison <jra@samba.org>
Tue, 7 Dec 2004 18:25:53 +0000 (18:25 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 15:53:32 +0000 (10:53 -0500)
functions so we can funnel through some well known functions. Should help greatly with
malloc checking.
HEAD patch to follow.
Jeremy.
(This used to be commit 620f2e608f70ba92f032720c031283d295c5c06a)

218 files changed:
source3/auth/auth.c
source3/auth/auth_ntlmssp.c
source3/auth/auth_util.c
source3/client/client.c
source3/client/clitar.c
source3/groupdb/mapping.c
source3/include/smb.h
source3/include/smb_macros.h
source3/intl/lang_tdb.c
source3/lib/access.c
source3/lib/account_pol.c
source3/lib/adt_tree.c
source3/lib/bitmap.c
source3/lib/charcnv.c
source3/lib/data_blob.c
source3/lib/debug.c
source3/lib/dprintf.c
source3/lib/gencache.c
source3/lib/iconv.c
source3/lib/interface.c
source3/lib/ldap_escape.c
source3/lib/messages.c
source3/lib/module.c
source3/lib/ms_fnmatch.c
source3/lib/privileges.c
source3/lib/secace.c
source3/lib/secacl.c
source3/lib/secdesc.c
source3/lib/server_mutex.c
source3/lib/smbldap.c
source3/lib/substitute.c
source3/lib/system.c
source3/lib/system_smbd.c
source3/lib/talloc.c
source3/lib/time.c
source3/lib/util.c
source3/lib/util_file.c
source3/lib/util_getent.c
source3/lib/util_pw.c
source3/lib/util_sid.c
source3/lib/util_sock.c
source3/lib/util_str.c
source3/lib/util_unistr.c
source3/lib/wins_srv.c
source3/lib/xfile.c
source3/libads/ads_struct.c
source3/libads/authdata.c
source3/libads/kerberos_keytab.c
source3/libads/kerberos_verify.c
source3/libads/krb5_setpw.c
source3/libads/ldap.c
source3/libads/ldap_printer.c
source3/libads/ldap_utils.c
source3/libads/sasl.c
source3/libsmb/asn1.c
source3/libsmb/clientgen.c
source3/libsmb/clifile.c
source3/libsmb/clilist.c
source3/libsmb/cliquota.c
source3/libsmb/clireadwrite.c
source3/libsmb/clitrans.c
source3/libsmb/conncache.c
source3/libsmb/libsmb_cache.c
source3/libsmb/libsmb_compat.c
source3/libsmb/libsmbclient.c
source3/libsmb/namequery.c
source3/libsmb/nmblib.c
source3/libsmb/ntlmssp.c
source3/libsmb/samlogon_cache.c
source3/libsmb/smb_signing.c
source3/libsmb/spnego.c
source3/locking/brlock.c
source3/locking/locking.c
source3/locking/posix.c
source3/modules/vfs_netatalk.c
source3/modules/vfs_recycle.c
source3/modules/vfs_shadow_copy.c
source3/nmbd/nmbd_become_lmb.c
source3/nmbd/nmbd_browserdb.c
source3/nmbd/nmbd_browsesync.c
source3/nmbd/nmbd_incomingrequests.c
source3/nmbd/nmbd_namelistdb.c
source3/nmbd/nmbd_nameregister.c
source3/nmbd/nmbd_packets.c
source3/nmbd/nmbd_processlogon.c
source3/nmbd/nmbd_responserecordsdb.c
source3/nmbd/nmbd_serverlistdb.c
source3/nmbd/nmbd_subnetdb.c
source3/nmbd/nmbd_synclists.c
source3/nmbd/nmbd_winsproxy.c
source3/nmbd/nmbd_winsserver.c
source3/nmbd/nmbd_workgroupdb.c
source3/nsswitch/wb_client.c
source3/nsswitch/winbindd.c
source3/nsswitch/winbindd_acct.c
source3/nsswitch/winbindd_ads.c
source3/nsswitch/winbindd_cache.c
source3/nsswitch/winbindd_cm.c
source3/nsswitch/winbindd_dual.c
source3/nsswitch/winbindd_group.c
source3/nsswitch/winbindd_misc.c
source3/nsswitch/winbindd_pam.c
source3/nsswitch/winbindd_passdb.c
source3/nsswitch/winbindd_rpc.c
source3/nsswitch/winbindd_user.c
source3/nsswitch/winbindd_util.c
source3/nsswitch/winbindd_wins.c
source3/nsswitch/wins.c
source3/param/loadparm.c
source3/param/params.c
source3/passdb/login_cache.c
source3/passdb/lookup_sid.c
source3/passdb/machine_sid.c
source3/passdb/passdb.c
source3/passdb/pdb_get_set.c
source3/passdb/pdb_interface.c
source3/passdb/pdb_ldap.c
source3/passdb/pdb_smbpasswd.c
source3/passdb/pdb_sql.c
source3/passdb/pdb_tdb.c
source3/passdb/privileges.c
source3/passdb/secrets.c
source3/passdb/util_sam_sid.c
source3/printing/load.c
source3/printing/notify.c
source3/printing/nt_printing.c
source3/printing/print_cups.c
source3/printing/print_generic.c
source3/printing/printing.c
source3/printing/printing_db.c
source3/registry/reg_cachehook.c
source3/registry/reg_db.c
source3/registry/reg_frontend.c
source3/registry/reg_objects.c
source3/registry/reg_printing.c
source3/rpc_client/cli_ds.c
source3/rpc_client/cli_echo.c
source3/rpc_client/cli_lsarpc.c
source3/rpc_client/cli_samr.c
source3/rpc_client/cli_spoolss.c
source3/rpc_client/cli_srvsvc.c
source3/rpc_parse/parse_dfs.c
source3/rpc_parse/parse_ds.c
source3/rpc_parse/parse_echo.c
source3/rpc_parse/parse_lsa.c
source3/rpc_parse/parse_misc.c
source3/rpc_parse/parse_net.c
source3/rpc_parse/parse_prs.c
source3/rpc_parse/parse_samr.c
source3/rpc_parse/parse_sec.c
source3/rpc_parse/parse_spoolss.c
source3/rpc_parse/parse_srv.c
source3/rpc_server/srv_dfs_nt.c
source3/rpc_server/srv_echo_nt.c
source3/rpc_server/srv_lsa_ds_nt.c
source3/rpc_server/srv_lsa_hnd.c
source3/rpc_server/srv_lsa_nt.c
source3/rpc_server/srv_netlog_nt.c
source3/rpc_server/srv_pipe.c
source3/rpc_server/srv_pipe_hnd.c
source3/rpc_server/srv_reg_nt.c
source3/rpc_server/srv_samr_nt.c
source3/rpc_server/srv_spoolss_nt.c
source3/rpc_server/srv_srvsvc_nt.c
source3/rpc_server/srv_util.c
source3/rpc_server/srv_wkssvc_nt.c
source3/rpcclient/cmd_echo.c
source3/rpcclient/cmd_lsarpc.c
source3/rpcclient/cmd_samr.c
source3/rpcclient/cmd_spoolss.c
source3/rpcclient/rpcclient.c
source3/sam/idmap.c
source3/sam/idmap_tdb.c
source3/smbd/blocking.c
source3/smbd/conn.c
source3/smbd/dir.c
source3/smbd/fake_file.c
source3/smbd/fileio.c
source3/smbd/files.c
source3/smbd/ipc.c
source3/smbd/lanman.c
source3/smbd/mangle_hash.c
source3/smbd/mangle_hash2.c
source3/smbd/msdfs.c
source3/smbd/notify.c
source3/smbd/ntquotas.c
source3/smbd/nttrans.c
source3/smbd/open.c
source3/smbd/oplock.c
source3/smbd/password.c
source3/smbd/posix_acls.c
source3/smbd/process.c
source3/smbd/reply.c
source3/smbd/sec_ctx.c
source3/smbd/session.c
source3/smbd/statcache.c
source3/smbd/trans2.c
source3/smbd/vfs.c
source3/tdb/tdb.c
source3/tdb/tdbback.c
source3/tdb/tdbutil.c
source3/utils/net.c
source3/utils/net_ads.c
source3/utils/net_cache.c
source3/utils/net_idmap.c
source3/utils/net_rap.c
source3/utils/net_rpc.c
source3/utils/net_rpc_join.c
source3/utils/net_rpc_printer.c
source3/utils/net_rpc_samsync.c
source3/utils/net_status.c
source3/utils/ntlm_auth.c
source3/utils/pdbedit.c
source3/utils/smbcacls.c
source3/utils/smbtree.c
source3/web/cgi.c
source3/web/neg_lang.c
source3/web/statuspage.c

index 7cfe3fc63945a8866ae2b15d42a4e40d22e55f43..b777e97cc9da35ce182f3f7d6053042a5cf69f7a 100644 (file)
@@ -49,7 +49,7 @@ NTSTATUS smb_register_auth(int version, const char *name, auth_init_function ini
                return NT_STATUS_OBJECT_NAME_COLLISION;
        }
        
-       entry = smb_xmalloc(sizeof(struct auth_init_function_entry));
+       entry = SMB_XMALLOC_P(struct auth_init_function_entry);
        entry->name = smb_xstrdup(name);
        entry->init = init;
 
@@ -347,7 +347,7 @@ static NTSTATUS make_auth_context(struct auth_context **auth_context)
 
        mem_ctx = talloc_init("authentication context");
        
-       *auth_context = talloc(mem_ctx, sizeof(**auth_context));
+       *auth_context = TALLOC_P(mem_ctx, struct auth_context);
        if (!*auth_context) {
                DEBUG(0,("make_auth_context: talloc failed!\n"));
                talloc_destroy(mem_ctx);
index 4b425056b11bf1252c0f92ed0b1559b4b7b3cd0b..0e2c359251d66d086c19dda906b782f449e2a185 100644 (file)
@@ -135,7 +135,7 @@ NTSTATUS auth_ntlmssp_start(AUTH_NTLMSSP_STATE **auth_ntlmssp_state)
 
        mem_ctx = talloc_init("AUTH NTLMSSP context");
        
-       *auth_ntlmssp_state = talloc_zero(mem_ctx, sizeof(**auth_ntlmssp_state));
+       *auth_ntlmssp_state = TALLOC_ZERO_P(mem_ctx, AUTH_NTLMSSP_STATE);
        if (!*auth_ntlmssp_state) {
                DEBUG(0,("auth_ntlmssp_start: talloc failed!\n"));
                talloc_destroy(mem_ctx);
index 1ef64ab8458535f3e853a8d3fabca3b3add53930..d985c0a54fcadb4af27427a49d28a8fa4f97c280 100644 (file)
@@ -132,7 +132,7 @@ static NTSTATUS make_user_info(auth_usersupplied_info **user_info,
 
        DEBUG(5,("attempting to make a user_info for %s (%s)\n", internal_username, smb_name));
 
-       *user_info = malloc(sizeof(**user_info));
+       *user_info = SMB_MALLOC_P(auth_usersupplied_info);
        if (!user_info) {
                DEBUG(0,("malloc failed for user_info (size %lu)\n", (unsigned long)sizeof(*user_info)));
                return NT_STATUS_NO_MEMORY;
@@ -142,7 +142,7 @@ static NTSTATUS make_user_info(auth_usersupplied_info **user_info,
 
        DEBUG(5,("making strings for %s's user_info struct\n", internal_username));
 
-       (*user_info)->smb_name.str = strdup(smb_name);
+       (*user_info)->smb_name.str = SMB_STRDUP(smb_name);
        if ((*user_info)->smb_name.str) { 
                (*user_info)->smb_name.len = strlen(smb_name);
        } else {
@@ -150,7 +150,7 @@ static NTSTATUS make_user_info(auth_usersupplied_info **user_info,
                return NT_STATUS_NO_MEMORY;
        }
        
-       (*user_info)->internal_username.str = strdup(internal_username);
+       (*user_info)->internal_username.str = SMB_STRDUP(internal_username);
        if ((*user_info)->internal_username.str) { 
                (*user_info)->internal_username.len = strlen(internal_username);
        } else {
@@ -158,7 +158,7 @@ static NTSTATUS make_user_info(auth_usersupplied_info **user_info,
                return NT_STATUS_NO_MEMORY;
        }
 
-       (*user_info)->domain.str = strdup(domain);
+       (*user_info)->domain.str = SMB_STRDUP(domain);
        if ((*user_info)->domain.str) { 
                (*user_info)->domain.len = strlen(domain);
        } else {
@@ -166,7 +166,7 @@ static NTSTATUS make_user_info(auth_usersupplied_info **user_info,
                return NT_STATUS_NO_MEMORY;
        }
 
-       (*user_info)->client_domain.str = strdup(client_domain);
+       (*user_info)->client_domain.str = SMB_STRDUP(client_domain);
        if ((*user_info)->client_domain.str) { 
                (*user_info)->client_domain.len = strlen(client_domain);
        } else {
@@ -174,7 +174,7 @@ static NTSTATUS make_user_info(auth_usersupplied_info **user_info,
                return NT_STATUS_NO_MEMORY;
        }
 
-       (*user_info)->wksta_name.str = strdup(wksta_name);
+       (*user_info)->wksta_name.str = SMB_STRDUP(wksta_name);
        if ((*user_info)->wksta_name.str) { 
                (*user_info)->wksta_name.len = strlen(wksta_name);
        } else {
@@ -523,7 +523,7 @@ static NTSTATUS create_nt_user_token(const DOM_SID *user_sid, const DOM_SID *gro
        int i;
        int sid_ndx;
        
-       if ((ptoken = malloc( sizeof(NT_USER_TOKEN) ) ) == NULL) {
+       if ((ptoken = SMB_MALLOC_P(NT_USER_TOKEN)) == NULL) {
                DEBUG(0, ("create_nt_token: Out of memory allocating token\n"));
                nt_status = NT_STATUS_NO_MEMORY;
                return nt_status;
@@ -533,7 +533,7 @@ static NTSTATUS create_nt_user_token(const DOM_SID *user_sid, const DOM_SID *gro
 
        ptoken->num_sids = n_groupSIDs + 5;
 
-       if ((ptoken->user_sids = (DOM_SID *)malloc( sizeof(DOM_SID) * ptoken->num_sids )) == NULL) {
+       if ((ptoken->user_sids = SMB_MALLOC_ARRAY( DOM_SID, ptoken->num_sids )) == NULL) {
                DEBUG(0, ("create_nt_token: Out of memory allocating SIDs\n"));
                nt_status = NT_STATUS_NO_MEMORY;
                return nt_status;
@@ -610,7 +610,7 @@ NT_USER_TOKEN *create_nt_token(uid_t uid, gid_t gid, int ngroups, gid_t *groups,
                return NULL;
        }
 
-       group_sids = malloc(sizeof(DOM_SID) * ngroups);
+       group_sids = SMB_MALLOC_ARRAY(DOM_SID, ngroups);
        if (!group_sids) {
                DEBUG(0, ("create_nt_token: malloc() failed for DOM_SID list!\n"));
                return NULL;
@@ -685,7 +685,7 @@ static NTSTATUS get_user_groups(const char *username, uid_t uid, gid_t gid,
        
        if (n_unix_groups > 0) {
        
-               *groups   = malloc(sizeof(DOM_SID) * n_unix_groups);
+               *groups   = SMB_MALLOC_ARRAY(DOM_SID, n_unix_groups);
                
                if (!*groups) {
                        DEBUG(0, ("get_user_group: malloc() failed for DOM_SID list!\n"));
@@ -715,7 +715,7 @@ static NTSTATUS get_user_groups(const char *username, uid_t uid, gid_t gid,
 
 static NTSTATUS make_server_info(auth_serversupplied_info **server_info)
 {
-       *server_info = malloc(sizeof(**server_info));
+       *server_info = SMB_MALLOC_P(auth_serversupplied_info);
        if (!*server_info) {
                DEBUG(0,("make_server_info: malloc failed!\n"));
                return NT_STATUS_NO_MEMORY;
@@ -1244,7 +1244,7 @@ NTSTATUS make_server_info_info3(TALLOC_CTX *mem_ctx,
        
        /* Create a 'combined' list of all SIDs we might want in the SD */
        
-       all_group_SIDs = malloc(sizeof(DOM_SID) * (info3->num_groups2 + info3->num_other_sids + n_lgroupSIDs));
+       all_group_SIDs = SMB_MALLOC_ARRAY(DOM_SID,info3->num_groups2 + info3->num_other_sids + n_lgroupSIDs);
        
        if (!all_group_SIDs) {
                DEBUG(0, ("malloc() failed for DOM_SID list!\n"));
@@ -1393,7 +1393,7 @@ BOOL make_auth_methods(struct auth_context *auth_context, auth_methods **auth_me
                smb_panic("make_auth_methods: pointer to auth_method pointer is NULL!\n");
        }
 
-       *auth_method = talloc(auth_context->mem_ctx, sizeof(**auth_method));
+       *auth_method = TALLOC_P(auth_context->mem_ctx, auth_methods);
        if (!*auth_method) {
                DEBUG(0,("make_auth_method: malloc failed!\n"));
                return False;
@@ -1428,7 +1428,7 @@ NT_USER_TOKEN *dup_nt_token(NT_USER_TOKEN *ptoken)
        if (!ptoken)
                return NULL;
 
-    if ((token = (NT_USER_TOKEN *)malloc( sizeof(NT_USER_TOKEN) ) ) == NULL)
+    if ((token = SMB_MALLOC_P(NT_USER_TOKEN)) == NULL)
         return NULL;
 
     ZERO_STRUCTP(token);
index 8c43f4e16e465f95e2c95575585b2ab67633cade..7470a7ba5fdb38f16ad48d30617fef86d66e9bca 100644 (file)
@@ -387,7 +387,7 @@ static void init_do_list_queue(void)
 {
        reset_do_list_queue();
        do_list_queue_size = 1024;
-       do_list_queue = malloc(do_list_queue_size);
+       do_list_queue = SMB_MALLOC(do_list_queue_size);
        if (do_list_queue == 0) { 
                d_printf("malloc fail for size %d\n",
                         (int)do_list_queue_size);
@@ -425,7 +425,7 @@ static void add_to_do_list_queue(const char* entry)
                do_list_queue_size *= 2;
                DEBUG(4,("enlarging do_list_queue to %d\n",
                         (int)do_list_queue_size));
-               dlq = Realloc(do_list_queue, do_list_queue_size);
+               dlq = SMB_REALLOC(do_list_queue, do_list_queue_size);
                if (! dlq) {
                        d_printf("failure enlarging do_list_queue to %d bytes\n",
                                 (int)do_list_queue_size);
@@ -704,7 +704,7 @@ static int do_get(char *rname, char *lname, BOOL reget)
        DEBUG(1,("getting file %s of size %.0f as %s ", 
                 rname, (double)size, lname));
 
-       if(!(data = (char *)malloc(read_size))) { 
+       if(!(data = (char *)SMB_MALLOC(read_size))) { 
                d_printf("malloc fail for size %d\n", read_size);
                cli_close(cli, fnum);
                return 1;
@@ -1112,7 +1112,7 @@ static int do_put(char *rname, char *lname, BOOL reput)
        DEBUG(1,("putting file %s as %s ",lname,
                 rname));
   
-       buf = (char *)malloc(maxwrite);
+       buf = (char *)SMB_MALLOC(maxwrite);
        if (!buf) {
                d_printf("ERROR: Not enough memory!\n");
                return 1;
@@ -1325,7 +1325,7 @@ static int file_find(struct file_list **list, const char *directory,
                                        return -1;
                                }
                        }
-                       entry = (struct file_list *) malloc(sizeof (struct file_list));
+                       entry = SMB_MALLOC_P(struct file_list);
                        if (!entry) {
                                d_printf("Out of memory in file_find\n");
                                closedir(dir);
@@ -2698,7 +2698,7 @@ static void completion_remote_filter(file_info *f, const char *mask, void *state
 
        if ((info->count < MAX_COMPLETIONS - 1) && (strncmp(info->text, f->name, info->len) == 0) && (strcmp(f->name, ".") != 0) && (strcmp(f->name, "..") != 0)) {
                if ((info->dirmask[0] == 0) && !(f->mode & aDIR))
-                       info->matches[info->count] = strdup(f->name);
+                       info->matches[info->count] = SMB_STRDUP(f->name);
                else {
                        pstring tmp;
 
@@ -2709,7 +2709,7 @@ static void completion_remote_filter(file_info *f, const char *mask, void *state
                        pstrcat(tmp, f->name);
                        if (f->mode & aDIR)
                                pstrcat(tmp, "/");
-                       info->matches[info->count] = strdup(tmp);
+                       info->matches[info->count] = SMB_STRDUP(tmp);
                }
                if (info->matches[info->count] == NULL)
                        return;
@@ -2740,7 +2740,7 @@ static char **remote_completion(const char *text, int len)
        if (len >= PATH_MAX)
                return(NULL);
 
-       info.matches = (char **)malloc(sizeof(info.matches[0])*MAX_COMPLETIONS);
+       info.matches = SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS);
        if (!info.matches) return NULL;
        info.matches[0] = NULL;
 
@@ -2761,9 +2761,9 @@ static char **remote_completion(const char *text, int len)
                goto cleanup;
 
        if (info.count == 2)
-               info.matches[0] = strdup(info.matches[1]);
+               info.matches[0] = SMB_STRDUP(info.matches[1]);
        else {
-               info.matches[0] = malloc(info.samelen+1);
+               info.matches[0] = SMB_MALLOC(info.samelen+1);
                if (!info.matches[0])
                        goto cleanup;
                strncpy(info.matches[0], info.matches[1], info.samelen);
@@ -2818,7 +2818,7 @@ static char **completion_fn(const char *text, int start, int end)
                char **matches;
                int i, len, samelen = 0, count=1;
 
-               matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS);
+               matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
                if (!matches) {
                        return NULL;
                }
@@ -2827,7 +2827,7 @@ static char **completion_fn(const char *text, int start, int end)
                len = strlen(text);
                for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
                        if (strncmp(text, commands[i].name, len) == 0) {
-                               matches[count] = strdup(commands[i].name);
+                               matches[count] = SMB_STRDUP(commands[i].name);
                                if (!matches[count])
                                        goto cleanup;
                                if (count == 1)
@@ -2844,10 +2844,10 @@ static char **completion_fn(const char *text, int start, int end)
                case 1:
                        goto cleanup;
                case 2:
-                       matches[0] = strdup(matches[1]);
+                       matches[0] = SMB_STRDUP(matches[1]);
                        break;
                default:
-                       matches[0] = malloc(samelen+1);
+                       matches[0] = SMB_MALLOC(samelen+1);
                        if (!matches[0])
                                goto cleanup;
                        strncpy(matches[0], matches[1], samelen);
index b4d6273f7bb695c8dd12c6e50aa78ea7202abff1..a92be1abe385e91a448bd03510af62c610a10643 100644 (file)
@@ -146,7 +146,7 @@ static char *string_create_s(int size)
 {
        char *tmp;
 
-       tmp = (char *)malloc(size+1);
+       tmp = (char *)SMB_MALLOC(size+1);
 
        if (tmp == NULL) {
                DEBUG(0, ("Out of memory in string_create_s\n"));
@@ -177,7 +177,7 @@ static void writetarheader(int f, const char *aname, SMB_BIG_UINT size, time_t m
        if (l+2 >= NAMSIZ) {
                /* write a GNU tar style long header */
                char *b;
-               b = (char *)malloc(l+TBLOCK+100);
+               b = (char *)SMB_MALLOC(l+TBLOCK+100);
                if (!b) {
                        DEBUG(0,("out of memory\n"));
                        exit(1);
@@ -385,7 +385,7 @@ static void initarbuf(void)
 {
        /* initialize tar buffer */
        tbufsiz=blocksize*TBLOCK;
-       tarbuf=malloc(tbufsiz);      /* FIXME: We might not get the buffer */
+       tarbuf=SMB_MALLOC(tbufsiz);      /* FIXME: We might not get the buffer */
 
        /* reset tar buffer pointer and tar file counter and total dumped */
        tp=0; ntarf=0; ttarf=0;
@@ -1059,7 +1059,7 @@ static char *get_longfilename(file_info2 finfo)
        /* finfo.size here is the length of the filename as written by the "/./@LongLink" name
         * header call. */
        int namesize = finfo.size + strlen(cur_dir) + 2;
-       char *longname = malloc(namesize);
+       char *longname = SMB_MALLOC(namesize);
        int offset = 0, left = finfo.size;
        BOOL first = True;
 
@@ -1506,7 +1506,7 @@ static int read_inclusion_file(char *filename)
        while ((! error) && (x_fgets(buf, sizeof(buf)-1, inclusion))) {
                if (inclusion_buffer == NULL) {
                        inclusion_buffer_size = 1024;
-                       if ((inclusion_buffer = malloc(inclusion_buffer_size)) == NULL) {
+                       if ((inclusion_buffer = SMB_MALLOC(inclusion_buffer_size)) == NULL) {
                                DEBUG(0,("failure allocating buffer to read inclusion file\n"));
                                error = 1;
                                break;
@@ -1520,7 +1520,7 @@ static int read_inclusion_file(char *filename)
                if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
                        char *ib;
                        inclusion_buffer_size *= 2;
-                       ib = Realloc(inclusion_buffer,inclusion_buffer_size);
+                       ib = SMB_REALLOC(inclusion_buffer,inclusion_buffer_size);
                        if (! ib) {
                                DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
                                                inclusion_buffer_size));
@@ -1539,7 +1539,7 @@ static int read_inclusion_file(char *filename)
 
        if (! error) {
                /* Allocate an array of clipn + 1 char*'s for cliplist */
-               cliplist = malloc((clipn + 1) * sizeof(char *));
+               cliplist = SMB_MALLOC_ARRAY(char *, clipn + 1);
                if (cliplist == NULL) {
                        DEBUG(0,("failure allocating memory for cliplist\n"));
                        error = 1;
@@ -1550,7 +1550,7 @@ static int read_inclusion_file(char *filename)
                                /* set current item to NULL so array will be null-terminated even if
                                                * malloc fails below. */
                                cliplist[i] = NULL;
-                               if ((tmpstr = (char *)malloc(strlen(p)+1)) == NULL) {
+                               if ((tmpstr = (char *)SMB_MALLOC(strlen(p)+1)) == NULL) {
                                        DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
                                        error = 1;
                                } else {
@@ -1720,7 +1720,7 @@ int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
                clipn=argc-Optind-1;
                clipcount = clipn;
 
-               if ((tmplist=malloc(clipn*sizeof(char *))) == NULL) {
+               if ((tmplist=SMB_MALLOC_ARRAY(char *,clipn)) == NULL) {
                        DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n", clipn));
                        return 0;
                }
@@ -1729,7 +1729,7 @@ int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
 
                        DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
 
-                       if ((tmpstr = (char *)malloc(strlen(cliplist[clipcount])+1)) == NULL) {
+                       if ((tmpstr = (char *)SMB_MALLOC(strlen(cliplist[clipcount])+1)) == NULL) {
                                DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", clipcount));
                                return 0;
                        }
@@ -1751,7 +1751,7 @@ int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
 #ifdef HAVE_REGEX_H
                int errcode;
 
-               if ((preg = (regex_t *)malloc(65536)) == NULL) {
+               if ((preg = (regex_t *)SMB_MALLOC(65536)) == NULL) {
 
                        DEBUG(0, ("Could not allocate buffer for regular expression search\n"));
                        return;
index 072304ed18baa3409211cf7e8b90ffc1de60d221..7095997dc8d4aeae40596be55fc655df4f2a788c 100644 (file)
@@ -469,7 +469,7 @@ static BOOL enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
                decode_sid_name_use(group_type, map.sid_name_use);
                DEBUG(11,("enum_group_mapping: returning group %s of type %s\n", map.nt_name ,group_type));
 
-               mapt=(GROUP_MAP *)Realloc((*rmap), (entries+1)*sizeof(GROUP_MAP));
+               mapt= SMB_REALLOC_ARRAY((*rmap), GROUP_MAP, entries+1);
                if (!mapt) {
                        DEBUG(0,("enum_group_mapping: Unable to enlarge group map!\n"));
                        SAFE_FREE(*rmap);
@@ -613,7 +613,7 @@ static NTSTATUS add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
                asprintf(&new_memberstring, "%s %s", (char *)(dbuf.dptr),
                         string_sid);
        } else {
-               new_memberstring = strdup(string_sid);
+               new_memberstring = SMB_STRDUP(string_sid);
        }
 
        if (new_memberstring == NULL)
@@ -753,7 +753,7 @@ static NTSTATUS del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
                return tdb_delete(tdb, kbuf) == 0 ?
                        NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 
-       member_string = strdup("");
+       member_string = SMB_STRDUP("");
 
        if (member_string == NULL) {
                SAFE_FREE(sids);
@@ -1292,7 +1292,7 @@ NTSTATUS pdb_default_enum_aliases(struct pdb_methods *methods,
        if (*num_aliases > max_entries)
                *num_aliases = max_entries;
 
-       *info = malloc(sizeof(struct acct_info) * (*num_aliases));
+       *info = SMB_MALLOC_ARRAY(struct acct_info, *num_aliases);
 
        for (i=0; i<*num_aliases; i++) {
                fstrcpy((*info)[i].acct_name, map[i+start_idx].nt_name);
index bc99a2a6fddf7aa0fd1511c8a2e87ea58b9f2768..49d3d29ac03ad827a9e9dcb66555a49c950a8110 100644 (file)
@@ -53,9 +53,6 @@ typedef int BOOL;
 #define _BOOL       /* So we don't typedef BOOL again in vfs.h */
 #endif
 
-/* limiting size of ipc replies */
-#define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
-
 #define SIZEOFWORD 2
 
 #ifndef DEF_CREATE_MASK
@@ -1656,7 +1653,7 @@ struct unix_error_map {
 #define SAFE_NETBIOS_CHARS ". -_"
 
 /* generic iconv conversion structure */
-typedef struct {
+typedef struct _smb_iconv_t {
        size_t (*direct)(void *cd, const char **inbuf, size_t *inbytesleft,
                         char **outbuf, size_t *outbytesleft);
        size_t (*pull)(void *cd, const char **inbuf, size_t *inbytesleft,
index a9e911c066ac2ced4d836a4051815271754c2d17..4fa9ffa5ace418c34caf98052185326ed1916333 100644 (file)
@@ -261,4 +261,92 @@ copy an IP address from one buffer to another
 
 #define IS_DC  (lp_server_role()==ROLE_DOMAIN_PDC || lp_server_role()==ROLE_DOMAIN_BDC) 
 
+/*****************************************************************************
+ Safe allocation macros.
+*****************************************************************************/
+
+#define SMB_MALLOC_ARRAY(type,count) (type *)malloc_array(sizeof(type),(count))
+#define SMB_REALLOC(p,s) Realloc((p),(s))
+#define SMB_REALLOC_ARRAY(p,type,count) (type *)realloc_array((p),sizeof(type),(count))
+#define SMB_CALLOC_ARRAY(type,count) (type *)calloc_array(sizeof(type),(count))
+#define SMB_XMALLOC_P(type) (type *)smb_xmalloc_array(sizeof(type),1)
+#define SMB_XMALLOC_ARRAY(type,count) (type *)smb_xmalloc_array(sizeof(type),(count))
+
+/* limiting size of ipc replies */
+#define SMB_REALLOC_LIMIT(ptr,size) SMB_REALLOC(ptr,MAX((size),4*1024))
+
+/* #define PARANOID_MALLOC_CHECKER 1 */
+
+#if defined(PARANOID_MALLOC_CHECKER)
+
+#define TALLOC(ctx, size) talloc_((ctx),(size))
+#define TALLOC_P(ctx, type) (type *)talloc_((ctx),sizeof(type))
+#define TALLOC_ARRAY(ctx, type, count) (type *)talloc_array_((ctx),sizeof(type),(count))
+#define TALLOC_MEMDUP(ctx, ptr, size) talloc_memdup_((ctx),(ptr),(size))
+#define TALLOC_ZERO(ctx, size) talloc_zero_((ctx),(size))
+#define TALLOC_ZERO_P(ctx, type) (type *)talloc_zero_((ctx),sizeof(type))
+#define TALLOC_ZERO_ARRAY(ctx, type, count) (type *)talloc_zero_array_((ctx),sizeof(type),(count))
+#define TALLOC_REALLOC(ctx, ptr, count) talloc_realloc_((ctx),(ptr),(count))
+#define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)talloc_realloc_array_((ctx),(ptr),sizeof(type),(count))
+
+#define PRS_ALLOC_MEM(ps, type, count) (type *)prs_alloc_mem_((ps),sizeof(type),(count))
+
+/* Get medieval on our ass about malloc.... */
+
+/* Restrictions on malloc/realloc/calloc. */
+#ifdef malloc
+#undef malloc
+#endif
+#define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
+
+#ifdef realloc
+#undef realloc
+#endif
+#define realloc(p,s) __ERROR_DONT_USE_REALLOC_DIRECTLY
+
+#ifdef calloc
+#undef calloc
+#endif
+#define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
+
+#ifdef strndup
+#undef strndup
+#endif
+#define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
+
+#ifdef strdup
+#undef strdup
+#endif
+#define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
+
+#define SMB_MALLOC(s) malloc_(s)
+#define SMB_MALLOC_P(type) (type *)malloc_(sizeof(type))
+
+#define SMB_STRDUP(s) smb_xstrdup(s)
+#define SMB_STRNDUP(s,n) smb_xstrndup(s,n)
+
+#else
+
+#define TALLOC(ctx, size) talloc((ctx),(size))
+#define TALLOC_P(ctx, type) (type *)talloc((ctx),sizeof(type))
+#define TALLOC_ARRAY(ctx, type, count) (type *)talloc_array((ctx),sizeof(type),(count))
+#define TALLOC_MEMDUP(ctx, ptr, size) talloc_memdup((ctx),(ptr),(size))
+#define TALLOC_ZERO(ctx, size) talloc_zero((ctx),(size))
+#define TALLOC_ZERO_P(ctx, type) (type *)talloc_zero((ctx),sizeof(type))
+#define TALLOC_ZERO_ARRAY(ctx, type, count) (type *)talloc_zero_array((ctx),sizeof(type),(count))
+#define TALLOC_REALLOC(ctx, ptr, count) talloc_realloc((ctx),(ptr),(count))
+#define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)talloc_realloc_array((ctx),(ptr),sizeof(type),(count))
+
+#define PRS_ALLOC_MEM(ps, type, count) (type *)prs_alloc_mem((ps),sizeof(type),(count))
+
+/* Regular malloc code. */
+
+#define SMB_MALLOC(s) malloc(s)
+#define SMB_MALLOC_P(type) (type *)malloc(sizeof(type))
+
+#define SMB_STRDUP(s) strdup(s)
+#define SMB_STRNDUP(s,n) strndup(s,n)
+
+#endif
+
 #endif /* _SMB_MACROS_H */
index fe2ad5b2fce48ab811600c2f282f6efd7f127607..d3422f0d78ac03d599ac2fc2898455ca083bf1be 100644 (file)
@@ -148,7 +148,7 @@ BOOL lang_tdb_init(const char *lang)
                                   strerror(errno)));
                        goto done;
                }
-               current_lang = strdup(lang);
+               current_lang = SMB_STRDUP(lang);
                result = True;
                goto done;
        }
@@ -160,7 +160,7 @@ BOOL lang_tdb_init(const char *lang)
                tdb_store_int32(tdb, "/LOADTIME/", (int)time(NULL));
        }
 
-       current_lang = strdup(lang);
+       current_lang = SMB_STRDUP(lang);
        result = True;
 
  done:
@@ -194,7 +194,7 @@ const char *lang_msg(const char *msgid)
                        count++;
        }
 
-       if (!(msgid_quoted = malloc(strlen(msgid) + count + 1)))
+       if (!(msgid_quoted = SMB_MALLOC(strlen(msgid) + count + 1)))
                return msgid;
 
        /* string_sub() is unsuitable here as it replaces some punctuation
@@ -221,7 +221,7 @@ const char *lang_msg(const char *msgid)
        /* if the message isn't found then we still need to return a pointer
           that can be freed. Pity. */
        if (!data.dptr)
-               return strdup(msgid);
+               return SMB_STRDUP(msgid);
 
        return (const char *)data.dptr;
 }
index f03f5daf333b3cf908333f0daf43274cb49f7b95..fcc795d1f266c15f80f3160990b4595a00a1f9e9 100644 (file)
@@ -86,7 +86,7 @@ static BOOL string_match(const char *tok,const char *s, char *invalid_char)
                        DEBUG(0,("Unable to get default yp domain.\n"));
                        return False;
                }
-               if (!(hostname = strdup(s))) {
+               if (!(hostname = SMB_STRDUP(s))) {
                        DEBUG(1,("out of memory for strdup!\n"));
                        return False;
                }
index 9120452e2e0c7c8cc2bb9202a9f136a9dfe2e83f..aa59383258490222d7f5488cdab3ba8903750dad 100644 (file)
@@ -88,7 +88,7 @@ char *account_policy_names_list(void)
                len += strlen(account_policy_names[i].string) + 1;
        }
        len++;
-       nl = malloc(len);
+       nl = SMB_MALLOC(len);
        if (!nl) {
                return NULL;
        }
index bd857e205ac150dfcc944e569b7991b3cd676ade..a5d6380377eee3a8aad2c45782c2fe9779be9010 100644 (file)
@@ -59,7 +59,7 @@ SORTED_TREE* sorted_tree_init( void *data_p,
 {
        SORTED_TREE *tree = NULL;
        
-       if ( !(tree = (SORTED_TREE*)malloc( sizeof(SORTED_TREE) )) )
+       if ( !(tree = SMB_MALLOC_P(SORTED_TREE)) )
                return NULL;
                
        ZERO_STRUCTP( tree );
@@ -67,7 +67,7 @@ SORTED_TREE* sorted_tree_init( void *data_p,
        tree->compare = cmp_fn;
        tree->free_func    = free_fn;
        
-       if ( !(tree->root = (TREE_NODE*)malloc( sizeof(TREE_NODE) )) ) {
+       if ( !(tree->root = SMB_MALLOC_P(TREE_NODE)) ) {
                SAFE_FREE( tree );
                return NULL;
        }
@@ -126,15 +126,15 @@ static TREE_NODE* sorted_tree_birth_child( TREE_NODE *node, char* key )
        TREE_NODE **siblings;
        int i;
        
-       if ( !(infant = (TREE_NODE*)malloc( sizeof(TREE_NODE) )) )
+       if ( !(infant = SMB_MALLOC_P(TREE_NODE)) )
                return NULL;
        
        ZERO_STRUCTP( infant );
                
-       infant->key = strdup( key );
+       infant->key = SMB_STRDUP( key );
        infant->parent = node;
        
-       siblings = Realloc( node->children, sizeof(TREE_NODE*)*(node->num_children+1) );
+       siblings = SMB_REALLOC_ARRAY( node->children, TREE_NODE *, node->num_children+1 );
        
        if ( siblings )
                node->children = siblings;
@@ -260,7 +260,7 @@ BOOL sorted_tree_add( SORTED_TREE *tree, const char *path, void *data_p )
        /* move past the first '/' */
        
        path++; 
-       path2 = strdup( path );
+       path2 = SMB_STRDUP( path );
        if ( !path2 ) {
                DEBUG(0,("sorted_tree_add: strdup() failed on string [%s]!?!?!\n", path));
                return False;
@@ -405,9 +405,9 @@ void* sorted_tree_find( SORTED_TREE *tree, char *key )
        /* make a copy to play with */
        
        if ( *key == '/' )
-               keystr = strdup( key+1 );
+               keystr = SMB_STRDUP( key+1 );
        else
-               keystr = strdup( key );
+               keystr = SMB_STRDUP( key );
        
        if ( !keystr ) {
                DEBUG(0,("sorted_tree_find: strdup() failed on string [%s]!?!?!\n", key));
index 3fa20cdd112c8429f39b253f6e953ec821001f8c..a6b52efe096946c1bbef71769710f317504f6a56 100644 (file)
@@ -30,12 +30,12 @@ struct bitmap *bitmap_allocate(int n)
 {
        struct bitmap *bm;
 
-       bm = (struct bitmap *)malloc(sizeof(*bm));
+       bm = SMB_MALLOC_P(struct bitmap);
 
        if (!bm) return NULL;
        
        bm->n = n;
-       bm->b = (uint32 *)malloc(sizeof(bm->b[0])*(n+31)/32);
+       bm->b = SMB_MALLOC_ARRAY(uint32, (n+31)/32);
        if (!bm->b) {
                SAFE_FREE(bm);
                return NULL;
@@ -68,12 +68,12 @@ struct bitmap *bitmap_talloc(TALLOC_CTX *mem_ctx, int n)
 
        if (!mem_ctx) return NULL;
 
-       bm = (struct bitmap *)talloc(mem_ctx, sizeof(*bm));
+       bm = TALLOC_P(mem_ctx, struct bitmap);
 
        if (!bm) return NULL;
        
        bm->n = n;
-       bm->b = (uint32 *)talloc(mem_ctx, sizeof(bm->b[0])*(n+31)/32);
+       bm->b = TALLOC_ARRAY(mem_ctx, uint32, (n+31)/32);
        if (!bm->b) {
                return NULL;
        }
index 95e24609cdf9648c7083c23012a1f9781fa7427f..e8ceaf39b7859df8aad3e6896fc6af2559937498 100644 (file)
@@ -538,9 +538,9 @@ size_t convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
        }
 
        if (ctx)
-               ob = (char *)talloc_realloc(ctx, ob, destlen);
+               ob = (char *)TALLOC_REALLOC(ctx, ob, destlen);
        else
-               ob = (char *)Realloc(ob, destlen);
+               ob = (char *)SMB_REALLOC(ob, destlen);
 
        if (!ob) {
                DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
@@ -588,9 +588,9 @@ size_t convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
 
        destlen = destlen - o_len;
        if (ctx)
-               *dest = (char *)talloc_realloc(ctx,ob,destlen);
+               *dest = (char *)TALLOC_REALLOC(ctx,ob,destlen);
        else
-               *dest = (char *)Realloc(ob,destlen);
+               *dest = (char *)SMB_REALLOC(ob,destlen);
        if (destlen && !*dest) {
                DEBUG(0, ("convert_string_allocate: out of memory!\n"));
                if (!ctx)
@@ -763,7 +763,7 @@ char *strdup_upper(const char *s)
                }
        }
 
-       return strdup(out_buffer);
+       return SMB_STRDUP(out_buffer);
 }
 
 size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
index 83afc591a1544f589a08bfc335d579990e94ed28..a1c3af2d492e8e47a2c6ea96801f0e3e52c103e8 100644 (file)
@@ -47,7 +47,7 @@ DATA_BLOB data_blob(const void *p, size_t length)
        if (p) {
                ret.data = smb_xmemdup(p, length);
        } else {
-               ret.data = smb_xmalloc(length);
+               ret.data = SMB_XMALLOC_ARRAY(char, length);
        }
        ret.length = length;
        ret.free = free_data_blob;
@@ -67,11 +67,11 @@ DATA_BLOB data_blob_talloc(TALLOC_CTX *mem_ctx, const void *p, size_t length)
        }
 
        if (p) {
-               ret.data = talloc_memdup(mem_ctx, p, length);
+               ret.data = TALLOC_MEMDUP(mem_ctx, p, length);
                if (ret.data == NULL)
                        smb_panic("data_blob_talloc: talloc_memdup failed.\n");
        } else {
-               ret.data = talloc(mem_ctx, length);
+               ret.data = TALLOC(mem_ctx, length);
                if (ret.data == NULL)
                        smb_panic("data_blob_talloc: talloc failed.\n");
        }
index 01aedb47740ec5fa1987ecb6a31a7fbe6aff5d02..b69a35ecd5c829f93cd8646f5f732604d7185e2c 100644 (file)
@@ -192,7 +192,7 @@ static char *debug_list_class_names_and_levels(void)
        if (DEBUGLEVEL_CLASS == &debug_all_class_hack)
                return NULL;
 
-       list = calloc(debug_num_classes + 1, sizeof(char *));
+       list = SMB_CALLOC_ARRAY(char *, debug_num_classes + 1);
        if (!list)
                return NULL;
 
@@ -210,7 +210,7 @@ static char *debug_list_class_names_and_levels(void)
        }
 
        /* create single string list - add space for newline */
-       b = buf = malloc(dim+1);
+       b = buf = SMB_MALLOC(dim+1);
        if (!buf) {
                err = True;
                goto done;
@@ -292,7 +292,7 @@ int debug_add_class(const char *classname)
                /* Initial loading... */
                new_ptr = NULL;
        }
-       new_ptr = Realloc(new_ptr, sizeof(int) * (debug_num_classes + 1));
+       new_ptr = SMB_REALLOC_ARRAY(new_ptr, int, debug_num_classes + 1);
        if (!new_ptr)
                return -1;
        DEBUGLEVEL_CLASS = new_ptr;
@@ -309,19 +309,18 @@ int debug_add_class(const char *classname)
        if (new_ptr == &debug_all_class_isset_hack) {
                new_ptr = NULL;
        }
-       new_ptr = Realloc(new_ptr, sizeof(BOOL) * (debug_num_classes + 1));
+       new_ptr = SMB_REALLOC_ARRAY(new_ptr, BOOL, debug_num_classes + 1);
        if (!new_ptr)
                return -1;
        DEBUGLEVEL_CLASS_ISSET = new_ptr;
        DEBUGLEVEL_CLASS_ISSET[ndx] = False;
 
-       new_ptr = Realloc(classname_table,
-                         sizeof(char *) * (debug_num_classes + 1));
+       new_ptr = SMB_REALLOC_ARRAY(classname_table, char *, debug_num_classes + 1);
        if (!new_ptr)
                return -1;
        classname_table = new_ptr;
 
-       classname_table[ndx] = strdup(classname);
+       classname_table[ndx] = SMB_STRDUP(classname);
        if (! classname_table[ndx])
                return -1;
        
index c62a1f41d10c8da71786b0fd1858984f62214a07..8ed2fa5d8cdaf505019de9e517d2ce9fb464071f 100644 (file)
@@ -54,7 +54,7 @@
           charset, but beware of it growing */
        maxlen = ret*2;
 again:
-       p2 = malloc(maxlen);
+       p2 = SMB_MALLOC(maxlen);
        if (!p2) {
                SAFE_FREE(p);
                return -1;
index 39e727c24fab0f9ff66184c2dff2dfd84ff28846..f2e267c9d4497d576881215d4b010f2879f4c100 100644 (file)
@@ -117,9 +117,9 @@ BOOL gencache_set(const char *keystr, const char *value, time_t timeout)
        if (!valstr)
                return False;
 
-       keybuf.dptr = strdup(keystr);
+       keybuf.dptr = SMB_STRDUP(keystr);
        keybuf.dsize = strlen(keystr)+1;
-       databuf.dptr = strdup(valstr);
+       databuf.dptr = SMB_STRDUP(valstr);
        databuf.dsize = strlen(valstr)+1;
        DEBUG(10, ("Adding cache entry with key = %s; value = %s and timeout ="
                   " %s (%d seconds %s)\n", keybuf.dptr, value,ctime(&timeout),
@@ -170,9 +170,9 @@ BOOL gencache_set_only(const char *keystr, const char *valstr, time_t timeout)
                   = %s\n", keystr, old_valstr, ctime(&old_timeout)));
 
        asprintf(&datastr, CACHE_DATA_FMT, (int)timeout, valstr);
-       keybuf.dptr = strdup(keystr);
+       keybuf.dptr = SMB_STRDUP(keystr);
        keybuf.dsize = strlen(keystr)+1;
-       databuf.dptr = strdup(datastr);
+       databuf.dptr = SMB_STRDUP(datastr);
        databuf.dsize = strlen(datastr)+1;
        DEBUGADD(10, ("New value = %s, new timeout = %s (%d seconds %s)", valstr,
                      ctime(&timeout), (int)(timeout - time(NULL)),
@@ -209,7 +209,7 @@ BOOL gencache_del(const char *keystr)
 
        if (!gencache_init()) return False;     
        
-       keybuf.dptr = strdup(keystr);
+       keybuf.dptr = SMB_STRDUP(keystr);
        keybuf.dsize = strlen(keystr)+1;
        DEBUG(10, ("Deleting cache entry (key = %s)\n", keystr));
        ret = tdb_delete(cache, keybuf);
@@ -242,18 +242,17 @@ BOOL gencache_get(const char *keystr, char **valstr, time_t *timeout)
        if (!gencache_init())
                return False;
        
-       keybuf.dptr = strdup(keystr);
+       keybuf.dptr = SMB_STRDUP(keystr);
        keybuf.dsize = strlen(keystr)+1;
        databuf = tdb_fetch(cache, keybuf);
        SAFE_FREE(keybuf.dptr);
        
        if (databuf.dptr && databuf.dsize > TIMEOUT_LEN) {
-               char* entry_buf = strndup(databuf.dptr, databuf.dsize);
+               char* entry_buf = SMB_STRNDUP(databuf.dptr, databuf.dsize);
                char *v;
                time_t t;
 
-               v = (char*)malloc(sizeof(char) * 
-                                 (databuf.dsize - TIMEOUT_LEN));
+               v = SMB_MALLOC(databuf.dsize - TIMEOUT_LEN);
                                
                SAFE_FREE(databuf.dptr);
                sscanf(entry_buf, CACHE_DATA_FMT, (int*)&t, v);
@@ -320,7 +319,7 @@ void gencache_iterate(void (*fn)(const char* key, const char *value, time_t time
        
        while (node) {
                /* ensure null termination of the key string */
-               keystr = strndup(node->node_key.dptr, node->node_key.dsize);
+               keystr = SMB_STRNDUP(node->node_key.dptr, node->node_key.dsize);
                
                /* 
                 * We don't use gencache_get function, because we need to iterate through
@@ -333,9 +332,9 @@ void gencache_iterate(void (*fn)(const char* key, const char *value, time_t time
                        node = node->next;
                        continue;
                }
-               entry = strndup(databuf.dptr, databuf.dsize);
+               entry = SMB_STRNDUP(databuf.dptr, databuf.dsize);
                SAFE_FREE(databuf.dptr);
-               valstr = (char*)malloc(sizeof(char) * (databuf.dsize - TIMEOUT_LEN));
+               valstr = SMB_MALLOC(databuf.dsize - TIMEOUT_LEN);
                sscanf(entry, CACHE_DATA_FMT, (int*)(&timeout), valstr);
                
                DEBUG(10, ("Calling function with arguments (key = %s, value = %s, timeout = %s)\n",
index 66a6e6cd8bc91adb6d455421d8d26130605d847f..d58165fed03271457f6ec31de9796215ce891d47 100644 (file)
@@ -209,15 +209,15 @@ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
        from = charsets;
        to = charsets;
 
-       ret = (smb_iconv_t)malloc(sizeof(*ret));
+       ret = SMB_MALLOC_P(struct _smb_iconv_t);
        if (!ret) {
                errno = ENOMEM;
                return (smb_iconv_t)-1;
        }
-       memset(ret, 0, sizeof(*ret));
+       memset(ret, 0, sizeof(struct _smb_iconv_t));
 
-       ret->from_name = strdup(fromcode);
-       ret->to_name = strdup(tocode);
+       ret->from_name = SMB_STRDUP(fromcode);
+       ret->to_name = SMB_STRDUP(tocode);
 
        /* check for the simplest null conversion */
        if (strcasecmp(fromcode, tocode) == 0) {
index adf9ca34381e45d723450fe6cbf2b816e13d73db..8cf11b850398626e8e657f6f4e9ca492b02a030e 100644 (file)
@@ -65,7 +65,7 @@ static void add_interface(struct in_addr ip, struct in_addr nmask)
                return;
        }
 
-       iface = (struct interface *)malloc(sizeof(*iface));
+       iface = SMB_MALLOC_P(struct interface);
        if (!iface) return;
        
        ZERO_STRUCTPN(iface);
@@ -207,7 +207,7 @@ void load_interfaces(void)
 
        if (ptr) {
                while (*ptr) {
-                       char *ptr_cpy = strdup(*ptr);
+                       char *ptr_cpy = SMB_STRDUP(*ptr);
                        if (ptr_cpy) {
                                interpret_interface(ptr_cpy);
                                free(ptr_cpy);
index 9e88b4999cc1c0e12b37b6d8a7c8eb040aa8e809..6c4e8b8c837e59ac0d4bec0bf72dc4136935df35 100644 (file)
@@ -36,7 +36,7 @@
 char *escape_ldap_string_alloc(const char *s)
 {
        size_t len = strlen(s)+1;
-       char *output = malloc(len);
+       char *output = SMB_MALLOC(len);
        char *output_tmp;
        const char *sub;
        int i = 0;
@@ -65,7 +65,7 @@ char *escape_ldap_string_alloc(const char *s)
                
                if (sub) {
                        len = len + 3;
-                       output_tmp = realloc(output, len);
+                       output_tmp = SMB_REALLOC(output, len);
                        if (!output_tmp) { 
                                SAFE_FREE(output);
                                return NULL;
index ded3ac95bb48414ece41aec6ad33032ddeae08b6..dca4b94844ad7ddb02c21292493cabf8a63f4918 100644 (file)
@@ -190,7 +190,7 @@ static BOOL message_send_pid_internal(pid_t pid, int msg_type, const void *buf,
 
        kbuf = message_key_pid(pid);
 
-       dbuf.dptr = (void *)malloc(len + sizeof(rec));
+       dbuf.dptr = (void *)SMB_MALLOC(len + sizeof(rec));
        if (!dbuf.dptr)
                return False;
 
@@ -468,7 +468,7 @@ void message_register(int msg_type,
 {
        struct dispatch_fns *dfn;
 
-       dfn = (struct dispatch_fns *)malloc(sizeof(*dfn));
+       dfn = SMB_MALLOC_P(struct dispatch_fns);
 
        if (dfn != NULL) {
 
index e469b1da422102450abcea78f7af48f94bf0b5e1..49121d12ca177d8617ad221be419200bc70972c3 100644 (file)
@@ -175,7 +175,7 @@ smb_event_id_t smb_register_idle_event(smb_idle_event_fn *fn, void *data, time_t
                return SMB_EVENT_ID_INVALID;
        }
 
-       event = (struct smb_idle_list_ent *)malloc(sizeof(struct smb_idle_list_ent));
+       event = SMB_MALLOC_P(struct smb_idle_list_ent);
        if (!event) {
                DEBUG(0,("malloc() failed!\n"));
                return SMB_EVENT_ID_INVALID;
@@ -257,7 +257,7 @@ smb_event_id_t smb_register_exit_event(smb_exit_event_fn *fn, void *data)
                return SMB_EVENT_ID_INVALID;
        }
 
-       event = (struct smb_exit_list_ent *)malloc(sizeof(struct smb_exit_list_ent));
+       event = SMB_MALLOC_P(struct smb_exit_list_ent);
        if (!event) {
                DEBUG(0,("malloc() failed!\n"));
                return SMB_EVENT_ID_INVALID;
index 71f3959c2416cd5d3c45065843173ffff776aeab..a0cbfd2ee21cbad8cdcbe119524727484420e93c 100644 (file)
@@ -204,7 +204,7 @@ int ms_fnmatch(const char *pattern, const char *string, enum protocol_types prot
        }
 
        if (count != 0) {
-               max_n = calloc(sizeof(struct max_n), count);
+               max_n = SMB_CALLOC_ARRAY(struct max_n, count);
                if (!max_n) {
                        return -1;
                }
index b9d4df301d95e24b12df8378af21a3aad4b8d1b9..2b8d7613c188ba2879a9cc5a05b4ddea2c7c7bbd 100644 (file)
@@ -75,7 +75,7 @@ NTSTATUS dupalloc_luid_attr(TALLOC_CTX *mem_ctx, LUID_ATTR **new_la, LUID_ATTR *
        if ( !old_la )
                return NT_STATUS_OK;
 
-       *new_la = (LUID_ATTR *)talloc(mem_ctx, sizeof(LUID_ATTR));
+       *new_la = TALLOC_P(mem_ctx, LUID_ATTR);
        ALLOC_CHECK(new_la, ret, done, "dupalloc_luid_attr");
 
        (*new_la)->luid.high = old_la->luid.high;
@@ -97,7 +97,7 @@ NTSTATUS init_privilege(PRIVILEGE_SET **priv_set)
        TALLOC_CTX *mem_ctx = talloc_init("privilege set");
        ALLOC_CHECK(mem_ctx, ret, done, "init_privilege");
 
-       *priv_set = talloc_zero(mem_ctx, sizeof(PRIVILEGE_SET));
+       *priv_set = TALLOC_ZERO_P(mem_ctx, PRIVILEGE_SET);
        ALLOC_CHECK(*priv_set, ret, done, "init_privilege");
 
        (*priv_set)->mem_ctx = mem_ctx;
@@ -112,7 +112,7 @@ NTSTATUS init_priv_with_ctx(TALLOC_CTX *mem_ctx, PRIVILEGE_SET **priv_set)
 {
        NTSTATUS ret;
 
-       *priv_set = talloc_zero(mem_ctx, sizeof(PRIVILEGE_SET));
+       *priv_set = TALLOC_ZERO_P(mem_ctx, PRIVILEGE_SET);
        ALLOC_CHECK(*priv_set, ret, done, "init_privilege");
 
        (*priv_set)->mem_ctx = mem_ctx;
@@ -154,7 +154,7 @@ NTSTATUS add_privilege(PRIVILEGE_SET *priv_set, LUID_ATTR set)
 
        /* we can allocate memory to add the new privilege */
 
-       new_set = (LUID_ATTR *)talloc_realloc(priv_set->mem_ctx, priv_set->set, (priv_set->count + 1) * (sizeof(LUID_ATTR)));
+       new_set = TALLOC_REALLOC_ARRAY(priv_set->mem_ctx, priv_set->set, LUID_ATTR, priv_set->count + 1);
        ALLOC_CHECK(new_set, ret, done, "add_privilege");
 
        new_set[priv_set->count].luid.high = set.luid.high;
@@ -269,7 +269,7 @@ NTSTATUS remove_privilege(PRIVILEGE_SET *priv_set, LUID_ATTR set)
 
        old_set = priv_set->set;
 
-       new_set = (LUID_ATTR *)talloc(priv_set->mem_ctx, (priv_set->count - 1) * (sizeof(LUID_ATTR)));
+       new_set = TALLOC_ARRAY(priv_set->mem_ctx, LUID_ATTR, priv_set->count - 1);
        ALLOC_CHECK(new_set, ret, done, "remove_privilege");
 
        for (i=0, j=0; i < priv_set->count; i++) {
@@ -329,7 +329,7 @@ NTSTATUS dup_priv_set(PRIVILEGE_SET *new_priv_set, PRIVILEGE_SET *priv_set)
 
        old_set = priv_set->set;
 
-       new_set = (LUID_ATTR *)talloc(new_priv_set->mem_ctx, (priv_set->count - 1) * (sizeof(LUID_ATTR)));
+       new_set = TALLOC_ARRAY(new_priv_set->mem_ctx, LUID_ATTR, priv_set->count - 1);
        ALLOC_CHECK(new_set, ret, done, "dup_priv_set");
 
        for (i=0; i < priv_set->count; i++) {
index 8c54c970433ce9e04c8571be74c3a6a9f5e528be..e44d9aa940ed763c5ee2aea7570855cdd513b4c9 100644 (file)
@@ -80,7 +80,7 @@ NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, SEC_ACE **new, SEC_ACE *old, unsigned
 
        *num += 1;
        
-       if((new[0] = (SEC_ACE *) talloc_zero(ctx, (*num) * sizeof(SEC_ACE))) == 0)
+       if((new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
                return NT_STATUS_NO_MEMORY;
 
        for (i = 0; i < *num - 1; i ++)
@@ -124,7 +124,7 @@ NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, SEC_ACE **new, SEC_ACE *old, uint32 *n
 
        if (!ctx || !new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
 
-       if((new[0] = (SEC_ACE *) talloc_zero(ctx, (*num) * sizeof(SEC_ACE))) == 0)
+       if((new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
                return NT_STATUS_NO_MEMORY;
 
        for (i = 0; i < *num; i ++) {
index 756685a8216192975d5e47792dcfbf464749938e..e213e0d9a0c2c2e5efcb29b14c113608d3557af2 100644 (file)
@@ -32,7 +32,7 @@ SEC_ACL *make_sec_acl(TALLOC_CTX *ctx, uint16 revision, int num_aces, SEC_ACE *a
        SEC_ACL *dst;
        int i;
 
-       if((dst = (SEC_ACL *)talloc_zero(ctx,sizeof(SEC_ACL))) == NULL)
+       if((dst = TALLOC_ZERO_P(ctx,SEC_ACL)) == NULL)
                return NULL;
 
        dst->revision = revision;
@@ -46,7 +46,7 @@ SEC_ACL *make_sec_acl(TALLOC_CTX *ctx, uint16 revision, int num_aces, SEC_ACE *a
           positive number. */
 
        if ((num_aces) && 
-            ((dst->ace = (SEC_ACE *)talloc(ctx, sizeof(SEC_ACE) * num_aces)) 
+            ((dst->ace = TALLOC_ARRAY(ctx, SEC_ACE, num_aces)) 
              == NULL)) {
                return NULL;
        }
index 411185dbfa6948d5dc23c6931c796fb28c85e2b8..686a4edf77ccb60f9a6ba9e661abc484cc3a0bfa 100644 (file)
@@ -187,7 +187,7 @@ SEC_DESC *make_sec_desc(TALLOC_CTX *ctx, uint16 revision, uint16 type,
 
        *sd_size = 0;
 
-       if(( dst = (SEC_DESC *)talloc_zero(ctx, sizeof(SEC_DESC))) == NULL)
+       if(( dst = TALLOC_ZERO_P(ctx, SEC_DESC)) == NULL)
                return NULL;
 
        dst->revision = revision;
@@ -284,7 +284,7 @@ SEC_DESC_BUF *make_sec_desc_buf(TALLOC_CTX *ctx, size_t len, SEC_DESC *sec_desc)
 {
        SEC_DESC_BUF *dst;
 
-       if((dst = (SEC_DESC_BUF *)talloc_zero(ctx, sizeof(SEC_DESC_BUF))) == NULL)
+       if((dst = TALLOC_ZERO_P(ctx, SEC_DESC_BUF)) == NULL)
                return NULL;
 
        /* max buffer size (allocated size) */
@@ -417,7 +417,7 @@ SEC_DESC_BUF *se_create_child_secdesc(TALLOC_CTX *ctx, SEC_DESC *parent_ctr,
 
        the_acl = parent_ctr->dacl;
 
-       if (!(new_ace_list = talloc(ctx, sizeof(SEC_ACE) * the_acl->num_aces))) 
+       if (!(new_ace_list = TALLOC_ARRAY(ctx, SEC_ACE, the_acl->num_aces))) 
                return NULL;
 
        for (i = 0; the_acl && i < the_acl->num_aces; i++) {
index 3e5512c734205d77720525cab9dc89af7af0972a..2267fba9c8865d59696368e0b65f68812645b1b9 100644 (file)
@@ -33,7 +33,7 @@ static char *mutex_server_name;
 
 BOOL grab_server_mutex(const char *name)
 {
-       mutex_server_name = strdup(name);
+       mutex_server_name = SMB_STRDUP(name);
        if (!mutex_server_name) {
                DEBUG(0,("grab_server_mutex: malloc failed for %s\n", name));
                return False;
index a1f42d92ee01e09ae1d35046dd4516f21fb89975..7e485457b084a3158175942d5260bbe8a3bd8fe5 100644 (file)
@@ -239,7 +239,7 @@ ATTRIB_MAP_ENTRY sidmap_attr_list[] = {
                i++;
        i++;
 
-       names = (char**)malloc( sizeof(char*)*i );
+       names = SMB_MALLOC_ARRAY( char*, i );
        if ( !names ) {
                DEBUG(0,("get_attr_list: out of memory\n"));
                return NULL;
@@ -247,7 +247,7 @@ ATTRIB_MAP_ENTRY sidmap_attr_list[] = {
 
        i = 0;
        while ( table[i].attrib != LDAP_ATTR_LIST_END ) {
-               names[i] = strdup( table[i].name );
+               names[i] = SMB_STRDUP( table[i].name );
                i++;
        }
        names[i] = NULL;
@@ -295,7 +295,7 @@ static BOOL fetch_ldap_pw(char **dn, char** pw)
        if (!size) {
                /* Upgrade 2.2 style entry */
                char *p;
-               char* old_style_key = strdup(*dn);
+               char* old_style_key = SMB_STRDUP(*dn);
                char *data;
                fstring old_style_pw;
                
@@ -408,7 +408,7 @@ static BOOL fetch_ldap_pw(char **dn, char** pw)
 #endif
 
        if (mods == NULL) {
-               mods = (LDAPMod **) malloc(sizeof(LDAPMod *));
+               mods = SMB_MALLOC_P(LDAPMod *);
                if (mods == NULL) {
                        DEBUG(0, ("make_a_mod: out of memory!\n"));
                        return;
@@ -422,19 +422,19 @@ static BOOL fetch_ldap_pw(char **dn, char** pw)
        }
 
        if (mods[i] == NULL) {
-               mods = (LDAPMod **) Realloc (mods, (i + 2) * sizeof (LDAPMod *));
+               mods = SMB_REALLOC_ARRAY (mods, LDAPMod *, i + 2);
                if (mods == NULL) {
                        DEBUG(0, ("make_a_mod: out of memory!\n"));
                        return;
                }
-               mods[i] = (LDAPMod *) malloc(sizeof(LDAPMod));
+               mods[i] = SMB_MALLOC_P(LDAPMod);
                if (mods[i] == NULL) {
                        DEBUG(0, ("make_a_mod: out of memory!\n"));
                        return;
                }
                mods[i]->mod_op = modop;
                mods[i]->mod_values = NULL;
-               mods[i]->mod_type = strdup(attribute);
+               mods[i]->mod_type = SMB_STRDUP(attribute);
                mods[i + 1] = NULL;
        }
 
@@ -445,8 +445,7 @@ static BOOL fetch_ldap_pw(char **dn, char** pw)
                if (mods[i]->mod_values != NULL) {
                        for (; mods[i]->mod_values[j] != NULL; j++);
                }
-               mods[i]->mod_values = (char **)Realloc(mods[i]->mod_values,
-                                              (j + 2) * sizeof (char *));
+               mods[i]->mod_values = SMB_REALLOC_ARRAY(mods[i]->mod_values, char *, j + 2);
                                               
                if (mods[i]->mod_values == NULL) {
                        DEBUG (0, ("make_a_mod: Memory allocation failure!\n"));
@@ -574,7 +573,7 @@ static void smbldap_store_state(LDAP *ld, struct smbldap_state *smbldap_state)
                return;
        }
 
-       t = smb_xmalloc(sizeof(*t));
+       t = SMB_XMALLOC_P(struct smbldap_state_lookup);
        ZERO_STRUCTP(t);
        
        DLIST_ADD_END(smbldap_state_lookup_list, t, tmp);
@@ -718,11 +717,11 @@ static int rebindproc_with_state  (LDAP * ld, char **whop, char **credp,
                DEBUG(5,("rebind_proc_with_state: Rebinding as \"%s\"\n", 
                          ldap_state->bind_dn));
 
-               *whop = strdup(ldap_state->bind_dn);
+               *whop = SMB_STRDUP(ldap_state->bind_dn);
                if (!*whop) {
                        return LDAP_NO_MEMORY;
                }
-               *credp = strdup(ldap_state->bind_secret);
+               *credp = SMB_STRDUP(ldap_state->bind_secret);
                if (!*credp) {
                        SAFE_FREE(*whop);
                        return LDAP_NO_MEMORY;
@@ -1211,7 +1210,7 @@ void smbldap_free_struct(struct smbldap_state **ldap_state)
 
 NTSTATUS smbldap_init(TALLOC_CTX *mem_ctx, const char *location, struct smbldap_state **smbldap_state) 
 {
-       *smbldap_state = talloc_zero(mem_ctx, sizeof(**smbldap_state));
+       *smbldap_state = TALLOC_ZERO_P(mem_ctx, struct smbldap_state);
        if (!*smbldap_state) {
                DEBUG(0, ("talloc() failed for ldapsam private_data!\n"));
                return NT_STATUS_NO_MEMORY;
index 92eff625f39129166f6f912c6d2bb6009eabc2ff..6ec3bb4a76e4fba78da811b125c9758abc8f5c46 100644 (file)
@@ -224,7 +224,7 @@ static char * realloc_expand_env_var(char *str, char *p)
 
        r = p + 3;
        copylen = q - r;
-       envname = (char *)malloc(copylen + 1 + 4); /* reserve space for use later add %$() chars */
+       envname = (char *)SMB_MALLOC(copylen + 1 + 4); /* reserve space for use later add %$() chars */
        if (envname == NULL) return NULL;
        strncpy(envname,r,copylen);
        envname[copylen] = '\0';
@@ -508,7 +508,7 @@ char *alloc_sub_basic(const char *smb_name, const char *str)
                return NULL;
        }
        
-       a_string = strdup(str);
+       a_string = SMB_STRDUP(str);
        if (a_string == NULL) {
                DEBUG(0, ("alloc_sub_specified: Out of memory!\n"));
                return NULL;
@@ -526,7 +526,7 @@ char *alloc_sub_basic(const char *smb_name, const char *str)
                        t = realloc_string_sub(t, "%U", r);
                        break;
                case 'G' :
-                       r = strdup(smb_name);
+                       r = SMB_STRDUP(smb_name);
                        if (r == NULL) goto error;
                        if ((pass = Get_Pwnam(r))!=NULL) {
                                t = realloc_string_sub(t, "%G", gidtoname(pass->pw_gid));
@@ -623,7 +623,7 @@ char *alloc_sub_specified(const char *input_string,
        char *a_string, *ret_string;
        char *b, *p, *s, *t;
 
-       a_string = strdup(input_string);
+       a_string = SMB_STRDUP(input_string);
        if (a_string == NULL) {
                DEBUG(0, ("alloc_sub_specified: Out of memory!\n"));
                return NULL;
@@ -700,7 +700,7 @@ char *alloc_sub_advanced(int snum, const char *user,
        char *a_string, *ret_string;
        char *b, *p, *s, *t, *h;
 
-       a_string = strdup(str);
+       a_string = SMB_STRDUP(str);
        if (a_string == NULL) {
                DEBUG(0, ("alloc_sub_specified: Out of memory!\n"));
                return NULL;
index f33d1ae7d576737b474ddacdd1236291237458ae..7434cbe35eea878021fa5bc3b7430b21629ebfc4 100644 (file)
@@ -1096,7 +1096,7 @@ static char **extract_args(const char *command)
        for( argcl = 1; ptr; ptr = strtok(NULL, " \t"))
                argcl++;
 
-       if((argl = (char **)malloc((argcl + 1) * sizeof(char *))) == NULL)
+       if((argl = (char **)SMB_MALLOC((argcl + 1) * sizeof(char *))) == NULL)
                return NULL;
 
        /*
@@ -1178,7 +1178,7 @@ int sys_popen(const char *command)
                goto err_exit;
        }
 
-       if((entry = (popen_list *)malloc(sizeof(popen_list))) == NULL)
+       if((entry = SMB_MALLOC_P(popen_list)) == NULL)
                goto err_exit;
 
        ZERO_STRUCTP(entry);
index fd2ed24a17c3c57845ca2d195efb87ce53e3df6f..eed607ee8fbde0915d0a9c5b44476b8d45e0a642 100644 (file)
@@ -53,7 +53,7 @@ static int getgrouplist_internals(const char *user, gid_t gid, gid_t *groups, in
                return -1;
        }
        
-       gids_saved = (gid_t *)malloc(sizeof(gid_t) * (ngrp_saved+1));
+       gids_saved = SMB_MALLOC_ARRAY(gid_t, ngrp_saved+1);
        if (!gids_saved) {
                errno = ENOMEM;
                return -1;
@@ -149,7 +149,7 @@ BOOL getgroups_user(const char *user, gid_t primary_gid,
        int i;
 
        max_grp = groups_max();
-       temp_groups = (gid_t *)malloc(sizeof(gid_t) * max_grp);
+       temp_groups = SMB_MALLOC_ARRAY(gid_t, max_grp);
        if (! temp_groups) {
                return False;
        }
@@ -158,7 +158,7 @@ BOOL getgroups_user(const char *user, gid_t primary_gid,
                
                gid_t *groups_tmp;
                
-               groups_tmp = Realloc(temp_groups, sizeof(gid_t) * max_grp);
+               groups_tmp = SMB_REALLOC_ARRAY(temp_groups, gid_t, max_grp);
                
                if (!groups_tmp) {
                        SAFE_FREE(temp_groups);
@@ -207,7 +207,7 @@ NTSTATUS pdb_default_enum_group_memberships(struct pdb_methods *methods,
                smb_panic("primary group missing");
        }
 
-       *sids = malloc(sizeof(**sids) * *num_groups);
+       *sids = SMB_MALLOC_ARRAY(DOM_SID, *num_groups);
 
        if (*sids == NULL) {
                SAFE_FREE(gids);
index 093a221fd3d44b40fe29d07da719b826c4a9ed1f..cafe0654790b31abc2c3ab6744a2381576e78328 100644 (file)
@@ -54,6 +54,8 @@
 
 #include "includes.h"
 
+/* Max allowable allococation - 256mb - 0x10000000 */
+#define MAX_TALLOC_SIZE (1024*1024*256)
 
 /**
  * Start of linked list of all talloc pools.
@@ -100,7 +102,7 @@ static TALLOC_CTX *talloc_init_internal(void)
 {
        TALLOC_CTX *t;
 
-       t = (TALLOC_CTX *)malloc(sizeof(TALLOC_CTX));
+       t = (TALLOC_CTX *)SMB_MALLOC(sizeof(TALLOC_CTX));
        if (t) {
                t->list = NULL;
                t->total_alloc_size = 0;
@@ -143,16 +145,20 @@ static TALLOC_CTX *talloc_init_internal(void)
 
 
 /** Allocate a bit of memory from the specified pool **/
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_(TALLOC_CTX *t, size_t size)
+#else
 void *talloc(TALLOC_CTX *t, size_t size)
+#endif
 {
        void *p;
        struct talloc_chunk *tc;
 
        if (!t || size == 0) return NULL;
 
-       p = malloc(size);
+       p = SMB_MALLOC(size);
        if (p) {
-               tc = malloc(sizeof(*tc));
+               tc = SMB_MALLOC(sizeof(*tc));
                if (tc) {
                        tc->ptr = p;
                        tc->size = size;
@@ -167,8 +173,25 @@ void *talloc(TALLOC_CTX *t, size_t size)
        return p;
 }
 
+/** Allocate an array of count elements of size x */
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_array_(TALLOC_CTX *ctx, size_t el_size, unsigned int count)
+#else
+void *talloc_array(TALLOC_CTX *ctx, size_t el_size, unsigned int count)
+#endif
+{
+        if (count >= MAX_TALLOC_SIZE/el_size) {
+                return NULL;
+        }
+       return TALLOC(ctx, el_size * count);
+}
+
 /** A talloc version of realloc */
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_realloc_(TALLOC_CTX *t, void *ptr, size_t size)
+#else
 void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
+#endif
 {
        struct talloc_chunk *tc;
        void *new_ptr;
@@ -179,11 +202,11 @@ void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
 
        /* realloc(NULL) is equavalent to malloc() */
        if (ptr == NULL)
-               return talloc(t, size);
+               return TALLOC(t, size);
 
        for (tc=t->list; tc; tc=tc->next) {
                if (tc->ptr == ptr) {
-                       new_ptr = Realloc(ptr, size);
+                       new_ptr = SMB_REALLOC(ptr, size);
                        if (new_ptr) {
                                t->total_alloc_size += (size - tc->size);
                                tc->size = size;
@@ -195,6 +218,19 @@ void *talloc_realloc(TALLOC_CTX *t, void *ptr, size_t size)
        return NULL;
 }
 
+/** Re-allocate an array of count elements of size x */
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_realloc_array_(TALLOC_CTX *ctx, void *ptr, size_t el_size, unsigned int count)
+#else
+void *talloc_realloc_array(TALLOC_CTX *ctx, void *ptr, size_t el_size, unsigned int count)
+#endif
+{
+        if (count >= MAX_TALLOC_SIZE/el_size) {
+                return NULL;
+        }
+       return TALLOC_REALLOC(ctx, ptr, el_size * count);
+}
+
 /** Destroy all the memory allocated inside @p t, but not @p t
  * itself. */
 void talloc_destroy_pool(TALLOC_CTX *t)
@@ -246,9 +282,13 @@ const char * talloc_pool_name(TALLOC_CTX const *t)
 
 
 /** talloc and zero memory. */
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_zero_(TALLOC_CTX *t, size_t size)
+#else
 void *talloc_zero(TALLOC_CTX *t, size_t size)
+#endif
 {
-       void *p = talloc(t, size);
+       void *p = TALLOC(t, size);
 
        if (p)
                memset(p, '\0', size);
@@ -256,10 +296,32 @@ void *talloc_zero(TALLOC_CTX *t, size_t size)
        return p;
 }
 
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_zero_array_(TALLOC_CTX *t, size_t el_size, unsigned int count)
+#else
+void *talloc_zero_array(TALLOC_CTX *t, size_t el_size, unsigned int count)
+#endif
+{
+#if defined(PARANOID_MALLOC_CHECKER)
+       void *p = talloc_array_(t, el_size, count);
+#else
+       void *p = talloc_array(t, el_size, count);
+#endif
+
+       if (p)
+               memset(p, '\0', el_size*count);
+
+       return p;
+}
+
 /** memdup with a talloc. */
+#if defined(PARANOID_MALLOC_CHECKER)
+void *talloc_memdup_(TALLOC_CTX *t, const void *p, size_t size)
+#else
 void *talloc_memdup(TALLOC_CTX *t, const void *p, size_t size)
+#endif
 {
-       void *newp = talloc(t,size);
+       void *newp = TALLOC(t,size);
 
        if (newp)
                memcpy(newp, p, size);
@@ -271,7 +333,7 @@ void *talloc_memdup(TALLOC_CTX *t, const void *p, size_t size)
 char *talloc_strdup(TALLOC_CTX *t, const char *p)
 {
        if (p)
-               return talloc_memdup(t, p, strlen(p) + 1);
+               return TALLOC_MEMDUP(t, p, strlen(p) + 1);
        else
                return NULL;
 }
@@ -298,7 +360,7 @@ char *talloc_strdup_upper(TALLOC_CTX *t, const char *p)
 smb_ucs2_t *talloc_strdup_w(TALLOC_CTX *t, const smb_ucs2_t *p)
 {
        if (p)
-               return talloc_memdup(t, p, (strlen_w(p) + 1) * sizeof(smb_ucs2_t));
+               return TALLOC_MEMDUP(t, p, (strlen_w(p) + 1) * sizeof(smb_ucs2_t));
        else
                return NULL;
 }
@@ -329,7 +391,7 @@ smb_ucs2_t *talloc_strdup_w(TALLOC_CTX *t, const smb_ucs2_t *p)
 
        len = vsnprintf(NULL, 0, fmt, ap2);
 
-       ret = talloc(t, len+1);
+       ret = TALLOC(t, len+1);
        if (ret) {
                VA_COPY(ap2, ap);
                vsnprintf(ret, len+1, fmt, ap2);
@@ -373,7 +435,7 @@ smb_ucs2_t *talloc_strdup_w(TALLOC_CTX *t, const smb_ucs2_t *p)
        s_len = strlen(s);
        len = vsnprintf(NULL, 0, fmt, ap2);
 
-       s = talloc_realloc(t, s, s_len + len+1);
+       s = TALLOC_REALLOC(t, s, s_len + len+1);
        if (!s) return NULL;
 
        VA_COPY(ap2, ap);
index e63e0b29659c2ff425e377382c97fd8556e22d04..e7b537151ff7cac32054029f170307f51f70a51f 100644 (file)
@@ -190,8 +190,7 @@ static int TimeZoneFaster(time_t t)
     time_t low,high;
 
     zone = TimeZone(t);
-    tdt = (struct dst_table *)Realloc(dst_table,
-                                             sizeof(dst_table[0])*(i+1));
+    tdt = SMB_REALLOC_ARRAY(dst_table, struct dst_table, i+1);
     if (!tdt) {
       DEBUG(0,("TimeZoneFaster: out of memory!\n"));
       SAFE_FREE(dst_table);
index 0d5c7d7f07b2229f2ab9ebc98773326f034e3c12..ce8495e82edc780c1c85f97694e0c60f0cd143d2 100644 (file)
@@ -23,6 +23,9 @@
 
 #include "includes.h"
 
+/* Max allowable allococation - 256mb - 0x10000000 */
+#define MAX_ALLOC_SIZE (1024*1024*256)
+
 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
 #ifdef WITH_NISPLUS_HOME
 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
@@ -79,7 +82,7 @@ static char **smb_my_netbios_names;
 BOOL set_global_myname(const char *myname)
 {
        SAFE_FREE(smb_myname);
-       smb_myname = strdup(myname);
+       smb_myname = SMB_STRDUP(myname);
        if (!smb_myname)
                return False;
        strupper_m(smb_myname);
@@ -98,7 +101,7 @@ const char *global_myname(void)
 BOOL set_global_myworkgroup(const char *myworkgroup)
 {
        SAFE_FREE(smb_myworkgroup);
-       smb_myworkgroup = strdup(myworkgroup);
+       smb_myworkgroup = SMB_STRDUP(myworkgroup);
        if (!smb_myworkgroup)
                return False;
        strupper_m(smb_myworkgroup);
@@ -117,7 +120,7 @@ const char *lp_workgroup(void)
 BOOL set_global_scope(const char *scope)
 {
        SAFE_FREE(smb_scope);
-       smb_scope = strdup(scope);
+       smb_scope = SMB_STRDUP(scope);
        if (!smb_scope)
                return False;
        strupper_m(smb_scope);
@@ -151,7 +154,7 @@ static BOOL allocate_my_netbios_names_array(size_t number)
        free_netbios_names_array();
 
        smb_num_netbios_names = number + 1;
-       smb_my_netbios_names = (char **)malloc( sizeof(char *) * smb_num_netbios_names );
+       smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
 
        if (!smb_my_netbios_names)
                return False;
@@ -164,7 +167,7 @@ static BOOL set_my_netbios_names(const char *name, int i)
 {
        SAFE_FREE(smb_my_netbios_names[i]);
 
-       smb_my_netbios_names[i] = strdup(name);
+       smb_my_netbios_names[i] = SMB_STRDUP(name);
        if (!smb_my_netbios_names[i])
                return False;
        strupper_m(smb_my_netbios_names[i]);
@@ -301,7 +304,7 @@ void add_gid_to_array_unique(gid_t gid, gid_t **gids, int *num)
                        return;
        }
        
-       *gids = Realloc(*gids, (*num+1) * sizeof(gid_t));
+       *gids = SMB_REALLOC_ARRAY(*gids, gid_t, *num+1);
 
        if (*gids == NULL)
                return;
@@ -351,7 +354,7 @@ const char *get_numlist(const char *p, uint32 **num, int *count)
        while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
                uint32 *tn;
                
-               tn = Realloc((*num), ((*count)+1) * sizeof(uint32));
+               tn = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
                if (tn == NULL) {
                        SAFE_FREE(*num);
                        return NULL;
@@ -727,7 +730,7 @@ ssize_t transfer_file_internal(int infd, int outfd, size_t n, ssize_t (*read_fn)
        size_t num_to_read_thistime;
        size_t num_written = 0;
 
-       if ((buf = malloc(TRANSFER_BUF_SIZE)) == NULL)
+       if ((buf = SMB_MALLOC(TRANSFER_BUF_SIZE)) == NULL)
                return -1;
 
        while (total < n) {
@@ -855,6 +858,82 @@ BOOL yesno(char *p)
        return(False);
 }
 
+#if defined(PARANOID_MALLOC_CHECKER)
+
+/****************************************************************************
+ Internal malloc wrapper. Externally visible.
+****************************************************************************/
+
+void *malloc_(size_t size)
+{
+#undef malloc
+       /* If we don't add an amount here the glibc memset seems to write
+          one byte over. */
+       return malloc(size+16);
+#define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
+}
+
+/****************************************************************************
+ Internal calloc wrapper. Not externally visible.
+****************************************************************************/
+
+static void *calloc_(size_t count, size_t size)
+{
+#undef calloc
+       /* If we don't add an amount here the glibc memset seems to write
+          one byte over. */
+       return calloc(count+1, size);
+#define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
+}
+
+/****************************************************************************
+ Internal realloc wrapper. Not externally visible.
+****************************************************************************/
+
+static void *realloc_(void *ptr, size_t size)
+{
+#undef realloc
+       /* If we don't add an amount here the glibc memset seems to write
+          one byte over. */
+       return realloc(ptr, size+16);
+#define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
+}
+
+#endif /* PARANOID_MALLOC_CHECKER */
+
+/****************************************************************************
+ Type-safe malloc.
+****************************************************************************/
+
+void *malloc_array(size_t el_size, unsigned int count)
+{
+       if (count >= MAX_ALLOC_SIZE/el_size) {
+               return NULL;
+       }
+
+#if defined(PARANOID_MALLOC_CHECKER)
+       return malloc_(el_size*count);
+#else
+       return malloc(el_size*count);
+#endif
+}
+
+/****************************************************************************
+ Type-safe calloc.
+****************************************************************************/
+
+void *calloc_array(size_t size, size_t nmemb)
+{
+       if (nmemb >= MAX_ALLOC_SIZE/size) {
+               return NULL;
+       }
+#if defined(PARANOID_MALLOC_CHECKER)
+       return calloc_(nmemb, size);
+#else
+       return calloc(nmemb, size);
+#endif
+}
+
 /****************************************************************************
  Expand a pointer to be a particular size.
 ****************************************************************************/
@@ -869,10 +948,17 @@ void *Realloc(void *p,size_t size)
                return NULL;
        }
 
+#if defined(PARANOID_MALLOC_CHECKER)
+       if (!p)
+               ret = (void *)malloc_(size);
+       else
+               ret = (void *)realloc_(p,size);
+#else
        if (!p)
                ret = (void *)malloc(size);
        else
                ret = (void *)realloc(p,size);
+#endif
 
        if (!ret)
                DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
@@ -880,17 +966,16 @@ void *Realloc(void *p,size_t size)
        return(ret);
 }
 
-void *Realloc_zero(void *ptr, size_t size)
+/****************************************************************************
+ Type-safe realloc.
+****************************************************************************/
+
+void *realloc_array(void *p,size_t el_size, unsigned int count)
 {
-       void *tptr = NULL;
-               
-       tptr = Realloc(ptr, size);
-       if(tptr == NULL)
+       if (count >= MAX_ALLOC_SIZE/el_size) {
                return NULL;
-
-       memset((char *)tptr,'\0',size);
-
-       return tptr;
+       }
+       return Realloc(p,el_size*count);
 }
 
 /****************************************************************************
@@ -1595,8 +1680,7 @@ void set_namearray(name_compare_entry **ppname_array, char *namelist)
        if(num_entries == 0)
                return;
 
-       if(( (*ppname_array) = (name_compare_entry *)malloc(
-                                       (num_entries + 1) * sizeof(name_compare_entry))) == NULL) {
+       if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
                DEBUG(0,("set_namearray: malloc fail\n"));
                return;
        }
@@ -1619,7 +1703,7 @@ void set_namearray(name_compare_entry **ppname_array, char *namelist)
                        break;
 
                (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
-               if(((*ppname_array)[i].name = strdup(nameptr)) == NULL) {
+               if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
                        DEBUG(0,("set_namearray: malloc fail (1)\n"));
                        return;
                }
@@ -2115,14 +2199,18 @@ int smb_mkstemp(char *template)
  malloc that aborts with smb_panic on fail or zero size.
  *****************************************************************/  
 
-void *smb_xmalloc(size_t size)
+void *smb_xmalloc_array(size_t size, unsigned int count)
 {
        void *p;
        if (size == 0)
-               smb_panic("smb_xmalloc: called with zero size.\n");
-       if ((p = malloc(size)) == NULL) {
-               DEBUG(0, ("smb_xmalloc() failed to allocate %lu bytes\n", (unsigned long)size));
-               smb_panic("smb_xmalloc: malloc fail.\n");
+               smb_panic("smb_xmalloc_array: called with zero size.\n");
+        if (count >= MAX_ALLOC_SIZE/size) {
+                smb_panic("smb_xmalloc: alloc size too large.\n");
+        }
+       if ((p = SMB_MALLOC(size*count)) == NULL) {
+               DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
+                       (unsigned long)size, (unsigned long)count));
+               smb_panic("smb_xmalloc_array: malloc fail.\n");
        }
        return p;
 }
@@ -2134,7 +2222,7 @@ void *smb_xmalloc(size_t size)
 void *smb_xmemdup(const void *p, size_t size)
 {
        void *p2;
-       p2 = smb_xmalloc(size);
+       p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
        memcpy(p2, p, size);
        return p2;
 }
@@ -2145,10 +2233,19 @@ void *smb_xmemdup(const void *p, size_t size)
 
 char *smb_xstrdup(const char *s)
 {
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef strdup
+#undef strdup
+#endif
+#endif
        char *s1 = strdup(s);
+#if defined(PARANOID_MALLOC_CHECKER)
+#define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
+#endif
        if (!s1)
                smb_panic("smb_xstrdup: malloc fail\n");
        return s1;
+
 }
 
 /**
@@ -2157,7 +2254,15 @@ char *smb_xstrdup(const char *s)
 
 char *smb_xstrndup(const char *s, size_t n)
 {
+#if defined(PARANOID_MALLOC_CHECKER)
+#ifdef strndup
+#undef strndup
+#endif
+#endif
        char *s1 = strndup(s, n);
+#if defined(PARANOID_MALLOC_CHECKER)
+#define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
+#endif
        if (!s1)
                smb_panic("smb_xstrndup: malloc fail\n");
        return s1;
@@ -2189,7 +2294,7 @@ void *memdup(const void *p, size_t size)
        void *p2;
        if (size == 0)
                return NULL;
-       p2 = malloc(size);
+       p2 = SMB_MALLOC(size);
        if (!p2)
                return NULL;
        memcpy(p2, p, size);
index 303d961df57de7b8b7dfa680d8d2016a87743bf2..963d610beffb5737d84e031dbf20b956be112b84 100644 (file)
@@ -282,7 +282,7 @@ char *fgets_slash(char *s2,int maxlen,XFILE *f)
 
        if (!s2) {
                maxlen = MIN(maxlen,8);
-               s = (char *)malloc(maxlen);
+               s = (char *)SMB_MALLOC(maxlen);
        }
 
        if (!s) {
@@ -325,7 +325,7 @@ char *fgets_slash(char *s2,int maxlen,XFILE *f)
                        char *t;
          
                        maxlen *= 2;
-                       t = (char *)Realloc(s,maxlen);
+                       t = (char *)SMB_REALLOC(s,maxlen);
                        if (!t) {
                                DEBUG(0,("fgets_slash: failed to expand buffer!\n"));
                                SAFE_FREE(s);
@@ -358,7 +358,7 @@ char *file_pload(char *syscmd, size_t *size)
        total = 0;
 
        while ((n = read(fd, buf, sizeof(buf))) > 0) {
-               tp = Realloc(p, total + n + 1);
+               tp = SMB_REALLOC(p, total + n + 1);
                if (!tp) {
                        DEBUG(0,("file_pload: failed to expand buffer!\n"));
                        close(fd);
@@ -397,7 +397,7 @@ char *fd_load(int fd, size_t *size)
                return NULL;
        }
 
-       p = (char *)malloc(sbuf.st_size+1);
+       p = (char *)SMB_MALLOC(sbuf.st_size+1);
        if (!p) {
                return NULL;
        }
@@ -492,7 +492,7 @@ static char **file_lines_parse(char *p, size_t size, int *numlines)
                if (s[0] == '\n') i++;
        }
 
-       ret = (char **)malloc(sizeof(ret[0])*(i+2));
+       ret = SMB_MALLOC_ARRAY(char *, i+2);
        if (!ret) {
                SAFE_FREE(p);
                return NULL;
index 4431d6a2a476603edcb110b09ba546d6573079fd..1b01cae5fa98b8942573bc27f1bb59d77790f121 100644 (file)
@@ -33,7 +33,7 @@ struct sys_grent * getgrent_list(void)
        struct sys_grent *gent;
        struct group *grp;
        
-       gent = (struct sys_grent *) malloc(sizeof(struct sys_grent));
+       gent = SMB_MALLOC_P(struct sys_grent);
        if (gent == NULL) {
                DEBUG (0, ("Out of memory in getgrent_list!\n"));
                return NULL;
@@ -53,11 +53,11 @@ struct sys_grent * getgrent_list(void)
                int i,num;
                
                if (grp->gr_name) {
-                       if ((gent->gr_name = strdup(grp->gr_name)) == NULL)
+                       if ((gent->gr_name = SMB_STRDUP(grp->gr_name)) == NULL)
                                goto err;
                }
                if (grp->gr_passwd) {
-                       if ((gent->gr_passwd = strdup(grp->gr_passwd)) == NULL)
+                       if ((gent->gr_passwd = SMB_STRDUP(grp->gr_passwd)) == NULL)
                                goto err;
                }
                gent->gr_gid = grp->gr_gid;
@@ -67,20 +67,20 @@ struct sys_grent * getgrent_list(void)
                        ;
                
                /* alloc space for gr_mem string pointers */
-               if ((gent->gr_mem = (char **) malloc((num+1) * sizeof(char *))) == NULL)
+               if ((gent->gr_mem = SMB_MALLOC_ARRAY(char *, num+1)) == NULL)
                        goto err;
 
                memset(gent->gr_mem, '\0', (num+1) * sizeof(char *));
 
                for (i=0; i < num; i++) {
-                       if ((gent->gr_mem[i] = strdup(grp->gr_mem[i])) == NULL)
+                       if ((gent->gr_mem[i] = SMB_STRDUP(grp->gr_mem[i])) == NULL)
                                goto err;
                }
                gent->gr_mem[num] = NULL;
                
                grp = getgrent();
                if (grp) {
-                       gent->next = (struct sys_grent *) malloc(sizeof(struct sys_grent));
+                       gent->next = SMB_MALLOC_P(struct sys_grent);
                        if (gent->next == NULL)
                                goto err;
                        gent = gent->next;
@@ -134,7 +134,7 @@ struct sys_pwent * getpwent_list(void)
        struct sys_pwent *pent;
        struct passwd *pwd;
        
-       pent = (struct sys_pwent *) malloc(sizeof(struct sys_pwent));
+       pent = SMB_MALLOC_P(struct sys_pwent);
        if (pent == NULL) {
                DEBUG (0, ("Out of memory in getpwent_list!\n"));
                return NULL;
@@ -146,31 +146,31 @@ struct sys_pwent * getpwent_list(void)
        while (pwd != NULL) {
                memset(pent, '\0', sizeof(struct sys_pwent));
                if (pwd->pw_name) {
-                       if ((pent->pw_name = strdup(pwd->pw_name)) == NULL)
+                       if ((pent->pw_name = SMB_STRDUP(pwd->pw_name)) == NULL)
                                goto err;
                }
                if (pwd->pw_passwd) {
-                       if ((pent->pw_passwd = strdup(pwd->pw_passwd)) == NULL)
+                       if ((pent->pw_passwd = SMB_STRDUP(pwd->pw_passwd)) == NULL)
                                goto err;
                }
                pent->pw_uid = pwd->pw_uid;
                pent->pw_gid = pwd->pw_gid;
                if (pwd->pw_gecos) {
-                       if ((pent->pw_gecos = strdup(pwd->pw_gecos)) == NULL)
+                       if ((pent->pw_gecos = SMB_STRDUP(pwd->pw_gecos)) == NULL)
                                goto err;
                }
                if (pwd->pw_dir) {
-                       if ((pent->pw_dir = strdup(pwd->pw_dir)) == NULL)
+                       if ((pent->pw_dir = SMB_STRDUP(pwd->pw_dir)) == NULL)
                                goto err;
                }
                if (pwd->pw_shell) {
-                       if ((pent->pw_shell = strdup(pwd->pw_shell)) == NULL)
+                       if ((pent->pw_shell = SMB_STRDUP(pwd->pw_shell)) == NULL)
                                goto err;
                }
 
                pwd = getpwent();
                if (pwd) {
-                       pent->next = (struct sys_pwent *) malloc(sizeof(struct sys_pwent));
+                       pent->next = SMB_MALLOC_P(struct sys_pwent);
                        if (pent->next == NULL)
                                goto err;
                        pent = pent->next;
@@ -223,12 +223,12 @@ static struct sys_userlist *add_members_to_userlist(struct sys_userlist *list_he
                ;
 
        for (i = 0; i < num_users; i++) {
-               struct sys_userlist *entry = (struct sys_userlist *)malloc(sizeof(*entry));
+               struct sys_userlist *entry = SMB_MALLOC_P(struct sys_userlist);
                if (entry == NULL) {
                        free_userlist(list_head);
                        return NULL;
                }
-               entry->unix_name = (char *)strdup(grp->gr_mem[i]);
+               entry->unix_name = (char *)SMB_STRDUP(grp->gr_mem[i]);
                if (entry->unix_name == NULL) {
                        SAFE_FREE(entry);
                        free_userlist(list_head);
index e102f2ef81844246c3ea8416f64f9d034b69e82d..0d7ffe09e9bc343a8b6358a9868d380e8c532a53 100644 (file)
@@ -24,7 +24,7 @@
 
 static struct passwd *alloc_copy_passwd(const struct passwd *from) 
 {
-       struct passwd *ret = smb_xmalloc(sizeof(struct passwd));
+       struct passwd *ret = SMB_XMALLOC_P(struct passwd);
        ZERO_STRUCTP(ret);
        ret->pw_name = smb_xstrdup(from->pw_name);
        ret->pw_passwd = smb_xstrdup(from->pw_passwd);
index 6b27fc84ddb31604dcb73b78ba1b996e0db28c21..197157a2f72356dec98befa84b48e14ba87e6adf 100644 (file)
@@ -304,7 +304,7 @@ BOOL string_to_sid(DOM_SID *sidout, const char *sidstr)
 
        memset((char *)sidout, '\0', sizeof(DOM_SID));
 
-       p = q = strdup(sidstr + 2);
+       p = q = SMB_STRDUP(sidstr + 2);
        if (p == NULL) {
                DEBUG(0, ("string_to_sid: out of memory!\n"));
                return False;
@@ -621,7 +621,7 @@ char *sid_binstring(const DOM_SID *sid)
 {
        char *buf, *s;
        int len = sid_size(sid);
-       buf = malloc(len);
+       buf = SMB_MALLOC(len);
        if (!buf)
                return NULL;
        sid_linearize(buf, len, sid);
@@ -641,7 +641,7 @@ DOM_SID *sid_dup_talloc(TALLOC_CTX *ctx, const DOM_SID *src)
        if(!src)
                return NULL;
        
-       if((dst = talloc_zero(ctx, sizeof(DOM_SID))) != NULL) {
+       if((dst = TALLOC_ZERO_P(ctx, DOM_SID)) != NULL) {
                sid_copy( dst, src);
        }
        
index 27a7551e3713f7cf40589246faa1e7f7d7f92d93..c09e4579c4d5468c3bca7afba05c29fc7a508a24 100644 (file)
@@ -818,7 +818,7 @@ BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs,
 
        timeout *= 1000;        /* convert to microseconds */
 
-       sockets = malloc(num_addrs * sizeof(*sockets));
+       sockets = SMB_MALLOC_ARRAY(int, num_addrs);
 
        if (sockets == NULL)
                return False;
index a758aece4cace7973a992a120b296fa242ba605e..c6b6570f5c436314d7f6962dd14af6261669fe82 100644 (file)
@@ -134,7 +134,7 @@ char **toktocliplist(int *ctok, const char *sep)
        *ctok=ictok;
        s=(char *)last_ptr;
        
-       if (!(ret=iret=malloc((ictok+1)*sizeof(char *))))
+       if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
                return NULL;
        
        while(ictok--) {    
@@ -815,7 +815,7 @@ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
        int i;
        char *hex_buffer;
 
-       *out_hex_buffer = smb_xmalloc((len*2)+1);
+       *out_hex_buffer = SMB_XMALLOC_ARRAY(char, (len*2)+1);
        hex_buffer = *out_hex_buffer;
 
        for (i = 0; i < len; i++)
@@ -863,7 +863,7 @@ static BOOL string_init(char **dest,const char *src)
 
        if (l == 0) {
                if (!null_string) {
-                       if((null_string = (char *)malloc(1)) == NULL) {
+                       if((null_string = (char *)SMB_MALLOC(1)) == NULL) {
                                DEBUG(0,("string_init: malloc fail for null_string.\n"));
                                return False;
                        }
@@ -871,7 +871,7 @@ static BOOL string_init(char **dest,const char *src)
                }
                *dest = null_string;
        } else {
-               (*dest) = strdup(src);
+               (*dest) = SMB_STRDUP(src);
                if ((*dest) == NULL) {
                        DEBUG(0,("Out of memory in string_init\n"));
                        return False;
@@ -990,7 +990,7 @@ char *realloc_string_sub(char *string, const char *pattern, const char *insert)
 
        s = string;
 
-       in = strdup(insert);
+       in = SMB_STRDUP(insert);
        if (!in) {
                DEBUG(0, ("realloc_string_sub: out of memory!\n"));
                return NULL;
@@ -1019,7 +1019,7 @@ char *realloc_string_sub(char *string, const char *pattern, const char *insert)
        while ((p = strstr_m(s,pattern))) {
                if (ld > 0) {
                        int offset = PTR_DIFF(s,string);
-                       char *t = Realloc(string, ls + ld + 1);
+                       char *t = SMB_REALLOC(string, ls + ld + 1);
                        if (!t) {
                                DEBUG(0, ("realloc_string_sub: out of memory!\n"));
                                SAFE_FREE(in);
@@ -1110,7 +1110,7 @@ static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *patte
                }
        }
 
-       r = rp = (smb_ucs2_t *)malloc((lt + 1)*(sizeof(smb_ucs2_t)));
+       r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
        if (!r) {
                DEBUG(0, ("all_string_sub_w: out of memory!\n"));
                return NULL;
@@ -1478,7 +1478,7 @@ char *binary_string(char *buf, int len)
        char *s;
        int i, j;
        const char *hex = "0123456789ABCDEF";
-       s = malloc(len * 3 + 1);
+       s = SMB_MALLOC(len * 3 + 1);
        if (!s)
                return NULL;
        for (j=i=0;i<len;i++) {
@@ -1533,7 +1533,7 @@ int fstr_sprintf(fstring s, const char *fmt, ...)
        char *ret;
        
        n = strnlen(s, n);
-       ret = malloc(n+1);
+       ret = SMB_MALLOC(n+1);
        if (!ret)
                return NULL;
        memcpy(ret, s, n);
@@ -1573,7 +1573,7 @@ char **str_list_make(const char *string, const char *sep)
        
        if (!string || !*string)
                return NULL;
-       s = strdup(string);
+       s = SMB_STRDUP(string);
        if (!s) {
                DEBUG(0,("str_list_make: Unable to allocate memory"));
                return NULL;
@@ -1587,7 +1587,7 @@ char **str_list_make(const char *string, const char *sep)
        while (next_token(&str, tok, sep, sizeof(tok))) {               
                if (num == lsize) {
                        lsize += S_LIST_ABS;
-                       rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
+                       rlist = SMB_REALLOC_ARRAY(list, char *, lsize +1);
                        if (!rlist) {
                                DEBUG(0,("str_list_make: Unable to allocate memory"));
                                str_list_free(&list);
@@ -1598,7 +1598,7 @@ char **str_list_make(const char *string, const char *sep)
                        memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
                }
                
-               list[num] = strdup(tok);
+               list[num] = SMB_STRDUP(tok);
                if (!list[num]) {
                        DEBUG(0,("str_list_make: Unable to allocate memory"));
                        str_list_free(&list);
@@ -1628,7 +1628,7 @@ BOOL str_list_copy(char ***dest, const char **src)
        while (src[num]) {
                if (num == lsize) {
                        lsize += S_LIST_ABS;
-                       rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
+                       rlist = SMB_REALLOC_ARRAY(list, char *, lsize +1);
                        if (!rlist) {
                                DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
                                str_list_free(&list);
@@ -1638,7 +1638,7 @@ BOOL str_list_copy(char ***dest, const char **src)
                        memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
                }
                
-               list[num] = strdup(src[num]);
+               list[num] = SMB_STRDUP(src[num]);
                if (!list[num]) {
                        DEBUG(0,("str_list_copy: Unable to allocate memory"));
                        str_list_free(&list);
@@ -1740,7 +1740,7 @@ BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
                        t = *list;
                        d = p -t;
                        if (ld) {
-                               t = (char *) malloc(ls +ld +1);
+                               t = (char *) SMB_MALLOC(ls +ld +1);
                                if (!t) {
                                        DEBUG(0,("str_list_substitute: Unable to allocate memory"));
                                        return False;
@@ -1863,7 +1863,7 @@ int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
                return 0;
        
        count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
-       if ( (*ip_list = (struct ip_service*)malloc(count * sizeof(struct ip_service))) == NULL ) {
+       if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
                DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
                return 0;
        }
@@ -2011,7 +2011,7 @@ char * base64_encode_data_blob(DATA_BLOB data)
        size_t out_cnt = 0;
        size_t len = data.length;
        size_t output_len = data.length * 2;
-       char *result = malloc(output_len); /* get us plenty of space */
+       char *result = SMB_MALLOC(output_len); /* get us plenty of space */
 
        while (len-- && out_cnt < (data.length * 2) - 5) {
                int c = (unsigned char) *(data.data++);
@@ -2072,11 +2072,11 @@ void string_append(char **left, const char *right)
        int new_len = strlen(right) + 1;
 
        if (*left == NULL) {
-               *left = malloc(new_len);
+               *left = SMB_MALLOC(new_len);
                *left[0] = '\0';
        } else {
                new_len += strlen(*left);
-               *left = Realloc(*left, new_len);
+               *left = SMB_REALLOC(*left, new_len);
        }
 
        if (*left == NULL)
index 997dde91c22e988e1267c6f38593203f6906400f..bb9d69b164d2b00aafeb0bda7abc2cbd21cecf6e 100644 (file)
@@ -61,7 +61,7 @@ void load_case_tables(void)
           not available */
        if (!upcase_table) {
                DEBUG(1,("creating lame upcase table\n"));
-               upcase_table = malloc(0x20000);
+               upcase_table = SMB_MALLOC(0x20000);
                for (i=0;i<0x10000;i++) {
                        smb_ucs2_t v;
                        SSVAL(&v, 0, i);
@@ -76,7 +76,7 @@ void load_case_tables(void)
 
        if (!lowcase_table) {
                DEBUG(1,("creating lame lowcase table\n"));
-               lowcase_table = malloc(0x20000);
+               lowcase_table = SMB_MALLOC(0x20000);
                for (i=0;i<0x10000;i++) {
                        smb_ucs2_t v;
                        SSVAL(&v, 0, i);
@@ -175,7 +175,7 @@ void init_valid_table(void)
        if (valid_table) free(valid_table);
 
        DEBUG(2,("creating default valid table\n"));
-       valid_table = malloc(0x10000);
+       valid_table = SMB_MALLOC(0x10000);
        for (i=0;i<128;i++)
                valid_table[i] = isalnum(i) || strchr(allowed,i);
        
@@ -302,7 +302,7 @@ char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str)
        char *s;
        int maxlen = (str->uni_str_len+1)*4;
        if (!str->buffer) return NULL;
-       s = (char *)talloc(ctx, maxlen); /* convervative */
+       s = (char *)TALLOC(ctx, maxlen); /* convervative */
        if (!s) return NULL;
        pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2, 
                  STR_NOALIGN);
@@ -586,7 +586,7 @@ smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
        smb_ucs2_t *dest;
        
        if (!len) len = strlen_w(src);
-       dest = (smb_ucs2_t *)malloc((len + 1) * sizeof(smb_ucs2_t));
+       dest = SMB_MALLOC_ARRAY(smb_ucs2_t, len + 1);
        if (!dest) {
                DEBUG(0,("strdup_w: out of memory!\n"));
                return NULL;
@@ -815,12 +815,12 @@ UNISTR2* ucs2_to_unistr2(TALLOC_CTX *ctx, UNISTR2* dst, smb_ucs2_t* src)
        
        /* allocate UNISTR2 destination if not given */
        if (!dst) {
-               dst = (UNISTR2*) talloc(ctx, sizeof(UNISTR2));
+               dst = TALLOC_P(ctx, UNISTR2);
                if (!dst)
                        return NULL;
        }
        if (!dst->buffer) {
-               dst->buffer = (uint16*) talloc(ctx, sizeof(uint16) * (len + 1));
+               dst->buffer = TALLOC_ARRAY(ctx, uint16, len + 1);
                if (!dst->buffer)
                        return NULL;
        }
index 4a54762fde74578d2432d44b6a77c7b87eb13052..b82e04e13ccea6b6ea2f2c7b6e840cc147cd7d7e 100644 (file)
@@ -72,8 +72,8 @@ static char *wins_srv_keystr(struct in_addr wins_ip, struct in_addr src_ip)
 {
        char *keystr = NULL, *wins_ip_addr = NULL, *src_ip_addr = NULL;
 
-       wins_ip_addr = strdup(inet_ntoa(wins_ip));
-       src_ip_addr = strdup(inet_ntoa(src_ip));
+       wins_ip_addr = SMB_STRDUP(inet_ntoa(wins_ip));
+       src_ip_addr = SMB_STRDUP(inet_ntoa(src_ip));
 
        if ( !wins_ip_addr || !src_ip_addr ) {
                DEBUG(0,("wins_srv_keystr: malloc error\n"));
@@ -212,9 +212,9 @@ char **wins_srv_tags(void)
        if (lp_wins_support()) {
                /* give the caller something to chew on. This makes
                   the rest of the logic simpler (ie. less special cases) */
-               ret = (char **)malloc(sizeof(char *)*2);
+               ret = SMB_MALLOC_ARRAY(char *, 2);
                if (!ret) return NULL;
-               ret[0] = strdup("*");
+               ret[0] = SMB_STRDUP("*");
                ret[1] = NULL;
                return ret;
        }
@@ -242,8 +242,8 @@ char **wins_srv_tags(void)
                }
 
                /* add it to the list */
-               ret = (char **)Realloc(ret, (count+2) * sizeof(char *));
-               ret[count] = strdup(t_ip.tag);
+               ret = SMB_REALLOC_ARRAY(ret, char *, count+2);
+               ret[count] = SMB_STRDUP(t_ip.tag);
                if (!ret[count]) break;
                count++;
        }
index da5ec126c1f9b94db09549eebe72e59b294424f2..5bb93179af35f96857bf163fe7770a892bddf17e 100644 (file)
@@ -80,7 +80,7 @@ static int x_allocate_buffer(XFILE *f)
 {
        if (f->buf) return 1;
        if (f->bufsize == 0) return 0;
-       f->buf = malloc(f->bufsize);
+       f->buf = SMB_MALLOC(f->bufsize);
        if (!f->buf) return 0;
        f->next = f->buf;
        return 1;
@@ -95,7 +95,7 @@ XFILE *x_fopen(const char *fname, int flags, mode_t mode)
 {
        XFILE *ret;
 
-       ret = (XFILE *)malloc(sizeof(XFILE));
+       ret = SMB_MALLOC_P(XFILE);
        if (!ret) return NULL;
 
        memset(ret, 0, sizeof(XFILE));
index 92f37093f460d1cbcf6df49ab077e1c7e34bc8e6..e8546f86f50c7f51efb65c0d76c0a922cc71649f 100644 (file)
@@ -31,7 +31,7 @@ char *ads_build_path(const char *realm, const char *sep, const char *field, int
        char *ret;
        int len;
        
-       r = strdup(realm);
+       r = SMB_STRDUP(realm);
 
        if (!r || !*r)
                return r;
@@ -42,7 +42,7 @@ char *ads_build_path(const char *realm, const char *sep, const char *field, int
 
        len = (numbits+1)*(strlen(field)+1) + strlen(r) + 1;
 
-       ret = malloc(len);
+       ret = SMB_MALLOC(len);
        if (!ret)
                return NULL;
 
@@ -87,12 +87,12 @@ ADS_STRUCT *ads_init(const char *realm,
 {
        ADS_STRUCT *ads;
        
-       ads = (ADS_STRUCT *)smb_xmalloc(sizeof(*ads));
+       ads = SMB_XMALLOC_P(ADS_STRUCT);
        ZERO_STRUCTP(ads);
        
-       ads->server.realm = realm? strdup(realm) : NULL;
-       ads->server.workgroup = workgroup ? strdup(workgroup) : NULL;
-       ads->server.ldap_server = ldap_server? strdup(ldap_server) : NULL;
+       ads->server.realm = realm? SMB_STRDUP(realm) : NULL;
+       ads->server.workgroup = workgroup ? SMB_STRDUP(workgroup) : NULL;
+       ads->server.ldap_server = ldap_server? SMB_STRDUP(ldap_server) : NULL;
 
        /* we need to know if this is a foreign realm */
        if (realm && *realm && !strequal(lp_realm(), realm)) {
index 29170af377e00de50e88df04334d570accf73b39..ccaf82124c66eaeba0d023e01807030d0a0731df 100644 (file)
@@ -59,7 +59,7 @@ static BOOL pac_io_unknown_type_10(const char *desc, UNKNOWN_TYPE_10 *type_10,
                return False;
 
        if (UNMARSHALLING(ps) && type_10->len) {
-               type_10->username = (uint16 *) prs_alloc_mem(ps, type_10->len);
+               type_10->username = PRS_ALLOC_MEM(ps, uint16, type_10->len);
                if (!type_10->username) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -85,8 +85,7 @@ static BOOL pac_io_krb_sids(const char *desc, KRB_SID_AND_ATTRS *sid_and_attr,
        depth++;
 
        if (UNMARSHALLING(ps)) {
-               sid_and_attr->sid = 
-                       (DOM_SID2 * ) prs_alloc_mem(ps, sizeof(DOM_SID2));
+               sid_and_attr->sid = PRS_ALLOC_MEM(ps, DOM_SID2, 1);
                if (!sid_and_attr->sid) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -135,8 +134,7 @@ static BOOL pac_io_krb_sid_and_attr_array(const char *desc,
                return False;
 
        if (UNMARSHALLING(ps)) {
-               array->krb_sid_and_attrs = (KRB_SID_AND_ATTRS *)
-                       prs_alloc_mem(ps, sizeof(KRB_SID_AND_ATTRS) * num);
+               array->krb_sid_and_attrs = PRS_ALLOC_MEM(ps, KRB_SID_AND_ATTRS, num);
                if (!array->krb_sid_and_attrs) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -199,8 +197,7 @@ static BOOL pac_io_group_membership_array(const char *desc,
                return False;
 
        if (UNMARSHALLING(ps)) {
-               array->group_membership = (GROUP_MEMBERSHIP *)
-                       prs_alloc_mem(ps, sizeof(GROUP_MEMBERSHIP) * num);
+               array->group_membership = PRS_ALLOC_MEM(ps, GROUP_MEMBERSHIP, num);
                if (!array->group_membership) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -423,7 +420,7 @@ static BOOL pac_io_pac_signature_data(const char *desc,
        if (!prs_uint32("type", ps, depth, &data->type))
                return False;
        if (UNMARSHALLING(ps)) {
-               data->signature = (unsigned char *)prs_alloc_mem(ps, siglen);
+               data->signature = PRS_ALLOC_MEM(ps, unsigned char, siglen);
                if (!data->signature) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -454,8 +451,7 @@ static BOOL pac_io_pac_info_hdr_ctr(const char *desc, PAC_INFO_HDR *hdr,
        }
 
        if (UNMARSHALLING(ps) && hdr->size > 0) {
-               hdr->ctr = (PAC_INFO_CTR *) 
-                       prs_alloc_mem(ps, sizeof(PAC_INFO_CTR));
+               hdr->ctr = PRS_ALLOC_MEM(ps, PAC_INFO_CTR, 1);
                if (!hdr->ctr) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -466,8 +462,7 @@ static BOOL pac_io_pac_info_hdr_ctr(const char *desc, PAC_INFO_HDR *hdr,
        case PAC_TYPE_LOGON_INFO:
                DEBUG(5, ("PAC_TYPE_LOGON_INFO\n"));
                if (UNMARSHALLING(ps))
-                       hdr->ctr->pac.logon_info = (PAC_LOGON_INFO *)
-                               prs_alloc_mem(ps, sizeof(PAC_LOGON_INFO));
+                       hdr->ctr->pac.logon_info = PRS_ALLOC_MEM(ps, PAC_LOGON_INFO, 1);
                if (!hdr->ctr->pac.logon_info) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -480,8 +475,7 @@ static BOOL pac_io_pac_info_hdr_ctr(const char *desc, PAC_INFO_HDR *hdr,
        case PAC_TYPE_SERVER_CHECKSUM:
                DEBUG(5, ("PAC_TYPE_SERVER_CHECKSUM\n"));
                if (UNMARSHALLING(ps))
-                       hdr->ctr->pac.srv_cksum = (PAC_SIGNATURE_DATA *)
-                               prs_alloc_mem(ps, sizeof(PAC_SIGNATURE_DATA));
+                       hdr->ctr->pac.srv_cksum = PRS_ALLOC_MEM(ps, PAC_SIGNATURE_DATA, 1);
                if (!hdr->ctr->pac.srv_cksum) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -494,8 +488,7 @@ static BOOL pac_io_pac_info_hdr_ctr(const char *desc, PAC_INFO_HDR *hdr,
        case PAC_TYPE_PRIVSVR_CHECKSUM:
                DEBUG(5, ("PAC_TYPE_PRIVSVR_CHECKSUM\n"));
                if (UNMARSHALLING(ps))
-                       hdr->ctr->pac.privsrv_cksum = (PAC_SIGNATURE_DATA *)
-                               prs_alloc_mem(ps, sizeof(PAC_SIGNATURE_DATA));
+                       hdr->ctr->pac.privsrv_cksum = PRS_ALLOC_MEM(ps, PAC_SIGNATURE_DATA, 1);
                if (!hdr->ctr->pac.privsrv_cksum) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -509,8 +502,7 @@ static BOOL pac_io_pac_info_hdr_ctr(const char *desc, PAC_INFO_HDR *hdr,
        case PAC_TYPE_UNKNOWN_10:
                DEBUG(5, ("PAC_TYPE_UNKNOWN_10\n"));
                if (UNMARSHALLING(ps))
-                       hdr->ctr->pac.type_10 = (UNKNOWN_TYPE_10 *)
-                               prs_alloc_mem(ps, sizeof(UNKNOWN_TYPE_10));
+                       hdr->ctr->pac.type_10 = PRS_ALLOC_MEM(ps, UNKNOWN_TYPE_10, 1);
                if (!hdr->ctr->pac.type_10) {
                        DEBUG(3, ("No memory available\n"));
                        return False;
@@ -571,9 +563,7 @@ static BOOL pac_io_pac_data(const char *desc, PAC_DATA *data,
                return False;
 
        if (UNMARSHALLING(ps) && data->num_buffers > 0) {
-               if ((data->pac_info_hdr_ptr = (PAC_INFO_HDR *) 
-                    prs_alloc_mem(ps, sizeof(PAC_INFO_HDR) * 
-                                  data->num_buffers)) == NULL) {
+               if ((data->pac_info_hdr_ptr = PRS_ALLOC_MEM(ps, PAC_INFO_HDR, data->num_buffers)) == NULL) {
                        return False;
                }
        }
@@ -606,7 +596,7 @@ PAC_DATA *decode_pac_data(DATA_BLOB *auth_data, TALLOC_CTX *ctx)
 
        data_blob_free(&pac_data_blob);
 
-       pac_data = (PAC_DATA *) talloc_zero(ctx, sizeof(PAC_DATA));
+       pac_data = TALLOC_ZERO_P(ctx, PAC_DATA);
        pac_io_pac_data("pac data", pac_data, &ps, 0);
 
        prs_mem_free(&ps);
index ec6a8c507809f460d51fd0b67fefd75522c45746..8475f70ec474f0600f1d6acafa72342d917dae58 100644 (file)
@@ -546,7 +546,7 @@ int ads_keytab_create_default(ADS_STRUCT *ads)
        if (!found) {
                goto done;
        }
-       oldEntries = (char **) malloc(found * sizeof(char *));
+       oldEntries = SMB_MALLOC_ARRAY(char *, found );
        if (!oldEntries) {
                DEBUG(1,("ads_keytab_create_default: Failed to allocate space to store the old keytab entries (malloc failed?).\n"));
                ret = -1;
index 848bd61accf7accac030dfcd23abbd2a22abe91c..f7cbe8674bbfc070c6c10f36971f0c0eb226c7cb 100644 (file)
@@ -174,7 +174,7 @@ static BOOL ads_secrets_verify_ticket(krb5_context context, krb5_auth_context au
        for (i=0;enctypes[i];i++) {
                krb5_keyblock *key = NULL;
 
-               if (!(key = (krb5_keyblock *)malloc(sizeof(*key)))) {
+               if (!(key = SMB_MALLOC_P(krb5_keyblock))) {
                        goto out;
                }
        
index 95825748514e12f194383c50dbf022544eafed08..dadce2593c85262aca7550fb5309cb8bf19c629b 100644 (file)
@@ -54,7 +54,7 @@ static DATA_BLOB encode_krb5_setpw(const char *principal, const char *password)
        DATA_BLOB ret;
 
 
-       princ = strdup(principal);
+       princ = SMB_STRDUP(principal);
 
        if ((c = strchr_m(princ, '/')) == NULL) {
            c = princ; 
@@ -156,7 +156,7 @@ static krb5_error_code build_kpasswd_request(uint16 pversion,
                return ret;
        }
 
-       packet->data = (char *)malloc(ap_req->length + cipherpw.length + 6);
+       packet->data = (char *)SMB_MALLOC(ap_req->length + cipherpw.length + 6);
        if (!packet->data)
                return -1;
 
@@ -407,7 +407,7 @@ static ADS_STATUS do_krb5_kpasswd_request(krb5_context context,
        free(chpw_req.data);
 
        chpw_rep.length = 1500;
-       chpw_rep.data = (char *) malloc(chpw_rep.length);
+       chpw_rep.data = (char *) SMB_MALLOC(chpw_rep.length);
        if (!chpw_rep.data) {
                close(sock);
                free(ap_req.data);
@@ -631,7 +631,7 @@ static ADS_STATUS ads_krb5_chg_password(const char *kdc_host,
     /* We have to obtain an INITIAL changepw ticket for changing password */
     asprintf(&chpw_princ, "kadmin/changepw@%s",
                                (char *) krb5_princ_realm(context, princ));
-    password = strdup(oldpw);
+    password = SMB_STRDUP(oldpw);
     ret = krb5_get_init_creds_password(context, &creds, princ, password,
                                           kerb_prompter, NULL, 
                                           0, chpw_princ, &opts);
index 7bddc0e9b517cd9d7579eca214ff30f86b875879..c18e253f7b2e463dbf49a78d3554770fbd045761 100644 (file)
@@ -119,7 +119,7 @@ static BOOL ads_try_connect(ADS_STRUCT *ads, const char *server, unsigned port)
        DEBUG(5,("ads_try_connect: trying ldap server '%s' port %u\n", server, port));
 
        /* this copes with inet_ntoa brokenness */
-       srv = strdup(server);
+       srv = SMB_STRDUP(server);
 
        ads->ld = ldap_open_with_timeout(srv, port, lp_ldap_timeout());
        if (!ads->ld) {
@@ -296,11 +296,11 @@ got_connection:
        }
 
        if (!ads->auth.realm) {
-               ads->auth.realm = strdup(ads->config.realm);
+               ads->auth.realm = SMB_STRDUP(ads->config.realm);
        }
 
        if (!ads->auth.kdc_server) {
-               ads->auth.kdc_server = strdup(inet_ntoa(ads->ldap_ip));
+               ads->auth.kdc_server = SMB_STRDUP(inet_ntoa(ads->ldap_ip));
        }
 
 #if KRB5_DNS_HACK
@@ -338,13 +338,13 @@ static struct berval *dup_berval(TALLOC_CTX *ctx, const struct berval *in_val)
 
        if (!in_val) return NULL;
 
-       value = talloc_zero(ctx, sizeof(struct berval));
+       value = TALLOC_ZERO_P(ctx, struct berval);
        if (value == NULL)
                return NULL;
        if (in_val->bv_len == 0) return value;
 
        value->bv_len = in_val->bv_len;
-       value->bv_val = talloc_memdup(ctx, in_val->bv_val, in_val->bv_len);
+       value->bv_val = TALLOC_MEMDUP(ctx, in_val->bv_val, in_val->bv_len);
        return value;
 }
 
@@ -358,9 +358,9 @@ static struct berval **ads_dup_values(TALLOC_CTX *ctx,
        int i;
        
        if (!in_vals) return NULL;
-       for (i=0; in_vals[i]; i++); /* count values */
-       values = (struct berval **) talloc_zero(ctx, 
-                                               (i+1)*sizeof(struct berval *));
+       for (i=0; in_vals[i]; i++)
+               ; /* count values */
+       values = TALLOC_ZERO_ARRAY(ctx, struct berval *, i+1);
        if (!values) return NULL;
 
        for (i=0; in_vals[i]; i++) {
@@ -378,8 +378,9 @@ static char **ads_push_strvals(TALLOC_CTX *ctx, const char **in_vals)
        int i;
        
        if (!in_vals) return NULL;
-       for (i=0; in_vals[i]; i++); /* count values */
-       values = (char ** ) talloc_zero(ctx, (i+1)*sizeof(char *));
+       for (i=0; in_vals[i]; i++)
+               ; /* count values */
+       values = TALLOC_ZERO_ARRAY(ctx, char *, i+1);
        if (!values) return NULL;
 
        for (i=0; in_vals[i]; i++) {
@@ -397,8 +398,9 @@ static char **ads_pull_strvals(TALLOC_CTX *ctx, const char **in_vals)
        int i;
        
        if (!in_vals) return NULL;
-       for (i=0; in_vals[i]; i++); /* count values */
-       values = (char **) talloc_zero(ctx, (i+1)*sizeof(char *));
+       for (i=0; in_vals[i]; i++)
+               ; /* count values */
+       values = TALLOC_ZERO_ARRAY(ctx, char *, i+1);
        if (!values) return NULL;
 
        for (i=0; in_vals[i]; i++) {
@@ -824,8 +826,7 @@ ADS_MODLIST ads_init_mods(TALLOC_CTX *ctx)
 #define ADS_MODLIST_ALLOC_SIZE 10
        LDAPMod **mods;
        
-       if ((mods = (LDAPMod **) talloc_zero(ctx, sizeof(LDAPMod *) * 
-                                            (ADS_MODLIST_ALLOC_SIZE + 1))))
+       if ((mods = TALLOC_ZERO_ARRAY(ctx, LDAPMod *, ADS_MODLIST_ALLOC_SIZE + 1)))
                /* -1 is safety to make sure we don't go over the end.
                   need to reset it to NULL before doing ldap modify */
                mods[ADS_MODLIST_ALLOC_SIZE] = (LDAPMod *) -1;
@@ -861,8 +862,8 @@ static ADS_STATUS ads_modlist_add(TALLOC_CTX *ctx, ADS_MODLIST *mods,
        for (curmod=0; modlist[curmod] && modlist[curmod] != (LDAPMod *) -1;
             curmod++);
        if (modlist[curmod] == (LDAPMod *) -1) {
-               if (!(modlist = talloc_realloc(ctx, modlist, 
-                       (curmod+ADS_MODLIST_ALLOC_SIZE+1)*sizeof(LDAPMod *))))
+               if (!(modlist = TALLOC_REALLOC_ARRAY(ctx, modlist, LDAPMod *,
+                               curmod+ADS_MODLIST_ALLOC_SIZE+1)))
                        return ADS_ERROR(LDAP_NO_MEMORY);
                memset(&modlist[curmod], 0, 
                       ADS_MODLIST_ALLOC_SIZE*sizeof(LDAPMod *));
@@ -870,7 +871,7 @@ static ADS_STATUS ads_modlist_add(TALLOC_CTX *ctx, ADS_MODLIST *mods,
                *mods = modlist;
        }
                
-       if (!(modlist[curmod] = talloc_zero(ctx, sizeof(LDAPMod))))
+       if (!(modlist[curmod] = TALLOC_ZERO_P(ctx, LDAPMod)))
                return ADS_ERROR(LDAP_NO_MEMORY);
        modlist[curmod]->mod_type = talloc_strdup(ctx, name);
        if (mod_op & LDAP_MOD_BVALUES) {
@@ -1046,11 +1047,11 @@ char *ads_ou_string(ADS_STRUCT *ads, const char *org_unit)
                ret = ads_default_ou_string(ads, WELL_KNOWN_GUID_COMPUTERS);
 
                /* samba4 might not yet respond to a wellknownobject-query */
-               return ret ? ret : strdup("cn=Computers");
+               return ret ? ret : SMB_STRDUP("cn=Computers");
        }
        
        if (strequal(org_unit, "Computers")) {
-               return strdup("cn=Computers");
+               return SMB_STRDUP("cn=Computers");
        }
 
        return ads_build_path(org_unit, "\\/", "ou=", 1);
@@ -1107,7 +1108,7 @@ char *ads_default_ou_string(ADS_STRUCT *ads, const char *wknguid)
        for (i=1; i < new_ln; i++) {
                char *s;
                asprintf(&s, "%s,%s", ret, wkn_dn_exp[i]);
-               ret = strdup(s);
+               ret = SMB_STRDUP(s);
                free(s);
        }
 
@@ -1741,7 +1742,7 @@ ADS_STATUS ads_join_realm(ADS_STRUCT *ads, const char *machine_name,
        char *machine;
 
        /* machine name must be lowercase */
-       machine = strdup(machine_name);
+       machine = SMB_STRDUP(machine_name);
        strlower_m(machine);
 
        /*
@@ -1791,7 +1792,7 @@ ADS_STATUS ads_leave_realm(ADS_STRUCT *ads, const char *hostname)
        int rc;
 
        /* hostname must be lowercase */
-       host = strdup(hostname);
+       host = SMB_STRDUP(hostname);
        strlower_m(host);
 
        status = ads_find_machine_acct(ads, &res, host);
@@ -1915,7 +1916,7 @@ ADS_STATUS ads_set_machine_sd(ADS_STRUCT *ads, const char *hostname, char *dn)
        if (!(mods = ads_init_mods(ctx))) return ADS_ERROR(LDAP_NO_MEMORY);
 
        bval.bv_len = prs_offset(&ps_wire);
-       bval.bv_val = talloc(ctx, bval.bv_len);
+       bval.bv_val = TALLOC(ctx, bval.bv_len);
        if (!bval.bv_val) {
                ret = ADS_ERROR(LDAP_NO_MEMORY);
                goto ads_set_sd_error;
@@ -2015,7 +2016,7 @@ char **ads_pull_strings(ADS_STRUCT *ads,
 
        *num_values = ldap_count_values(values);
 
-       ret = talloc(mem_ctx, sizeof(char *) * (*num_values+1));
+       ret = TALLOC_ARRAY(mem_ctx, char *, *num_values + 1);
        if (!ret) {
                ldap_value_free(values);
                return NULL;
@@ -2126,9 +2127,8 @@ char **ads_pull_strings_range(ADS_STRUCT *ads,
                return NULL;
        }
 
-       strings = talloc_realloc(mem_ctx, current_strings,
-                                sizeof(*current_strings) *
-                                (*num_strings + num_new_strings));
+       strings = TALLOC_REALLOC_ARRAY(mem_ctx, current_strings, char *,
+                                *num_strings + num_new_strings);
        
        if (strings == NULL) {
                ldap_memfree(range_attr);
@@ -2265,7 +2265,7 @@ int ads_pull_sids(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
        for (i=0; values[i]; i++)
                /* nop */ ;
 
-       (*sids) = talloc(mem_ctx, sizeof(DOM_SID) * i);
+       (*sids) = TALLOC_ARRAY(mem_ctx, DOM_SID, i);
        if (!(*sids)) {
                ldap_value_free_len(values);
                return 0;
@@ -2446,7 +2446,7 @@ ADS_STATUS ads_server_info(ADS_STRUCT *ads)
 
        SAFE_FREE(ads->config.ldap_server_name);
 
-       ads->config.ldap_server_name = strdup(p+1);
+       ads->config.ldap_server_name = SMB_STRDUP(p+1);
        p = strchr(ads->config.ldap_server_name, '$');
        if (!p || p[1] != '@') {
                talloc_destroy(ctx);
@@ -2461,7 +2461,7 @@ ADS_STATUS ads_server_info(ADS_STRUCT *ads)
        SAFE_FREE(ads->config.realm);
        SAFE_FREE(ads->config.bind_path);
 
-       ads->config.realm = strdup(p+2);
+       ads->config.realm = SMB_STRDUP(p+2);
        ads->config.bind_path = ads_build_dn(ads->config.realm);
 
        DEBUG(3,("got ldap server name %s@%s, using bind path: %s\n", 
index d8e4cefcfaa6fbce31b0afd40c26e1aa0c053cf4..68e6735891038a1de49a390e0cc6e8abb8189605 100644 (file)
@@ -161,10 +161,9 @@ static BOOL map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
        };
 
        if (num_vals) {
-               str_values = talloc(ctx, 
-                                   (num_vals + 1) * sizeof(smb_ucs2_t *));
+               str_values = TALLOC_ARRAY(ctx, char *, num_vals + 1);
                memset(str_values, '\0', 
-                      (num_vals + 1) * sizeof(smb_ucs2_t *));
+                      (num_vals + 1) * sizeof(char *));
 
                cur_str = (smb_ucs2_t *) value->data_p;
                for (i=0; i < num_vals; i++)
index 991f16c84544791bd7baa03d16527f5fd438f5d2..03cdd339f0d25996d31263d0f33389c2f059a358 100644 (file)
@@ -42,7 +42,7 @@ ADS_STATUS ads_do_search_retry(ADS_STRUCT *ads, const char *bind_path, int scope
                return ADS_ERROR(LDAP_SERVER_DOWN);
        }
 
-       bp = strdup(bind_path);
+       bp = SMB_STRDUP(bind_path);
 
        if (!bp) {
                return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
index 8eb2c86bed5e1cac6565a792b2ae77df6e2356db..97ba9c92862792cab182505a0e1a43cc650f14e6 100644 (file)
@@ -374,7 +374,7 @@ static ADS_STATUS ads_sasl_gssapi_bind(ADS_STRUCT *ads)
 
        gss_release_buffer(&minor_status, &output_token);
 
-       output_token.value = malloc(strlen(ads->config.bind_path) + 8);
+       output_token.value = SMB_MALLOC(strlen(ads->config.bind_path) + 8);
        p = output_token.value;
 
        *p++ = 1; /* no sign & seal selection */
index 2807b4e1d3e0e1d718be69456f46f7e9f25ba763..6db12fc6125d8d57e86bc2512cb8ad8167a0f90a 100644 (file)
@@ -32,7 +32,7 @@ BOOL asn1_write(ASN1_DATA *data, const void *p, int len)
        if (data->has_error) return False;
        if (data->length < data->ofs+len) {
                uint8 *newp;
-               newp = Realloc(data->data, data->ofs+len);
+               newp = SMB_REALLOC(data->data, data->ofs+len);
                if (!newp) {
                        SAFE_FREE(data->data);
                        data->has_error = True;
@@ -58,7 +58,7 @@ BOOL asn1_push_tag(ASN1_DATA *data, uint8 tag)
        struct nesting *nesting;
 
        asn1_write_uint8(data, tag);
-       nesting = (struct nesting *)malloc(sizeof(struct nesting));
+       nesting = SMB_MALLOC_P(struct nesting);
        if (!nesting) {
                data->has_error = True;
                return False;
@@ -255,7 +255,7 @@ BOOL asn1_start_tag(ASN1_DATA *data, uint8 tag)
                data->has_error = True;
                return False;
        }
-       nesting = (struct nesting *)malloc(sizeof(struct nesting));
+       nesting = SMB_MALLOC_P(struct nesting);
        if (!nesting) {
                data->has_error = True;
                return False;
@@ -350,7 +350,7 @@ BOOL asn1_read_OID(ASN1_DATA *data, char **OID)
 
        asn1_end_tag(data);
 
-       *OID = strdup(oid_str);
+       *OID = SMB_STRDUP(oid_str);
 
        return !data->has_error;
 }
@@ -380,7 +380,7 @@ BOOL asn1_read_GeneralString(ASN1_DATA *data, char **s)
                data->has_error = True;
                return False;
        }
-       *s = malloc(len+1);
+       *s = SMB_MALLOC(len+1);
        if (! *s) {
                data->has_error = True;
                return False;
index 974ebf91f5ce2004dc9a2ca74b95a9f471c736c6..682e0d8b85a92bd5b1c937dcd0f17c6029445917 100644 (file)
@@ -253,7 +253,7 @@ struct cli_state *cli_initialise(struct cli_state *cli)
        }
 
        if (!cli) {
-               cli = (struct cli_state *)malloc(sizeof(*cli));
+               cli = SMB_MALLOC_P(struct cli_state);
                if (!cli)
                        return NULL;
                ZERO_STRUCTP(cli);
@@ -275,8 +275,8 @@ struct cli_state *cli_initialise(struct cli_state *cli)
        cli->timeout = 20000; /* Timeout is in milliseconds. */
        cli->bufsize = CLI_BUFFER_SIZE+4;
        cli->max_xmit = cli->bufsize;
-       cli->outbuf = (char *)malloc(cli->bufsize+SAFETY_MARGIN);
-       cli->inbuf = (char *)malloc(cli->bufsize+SAFETY_MARGIN);
+       cli->outbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
+       cli->inbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
        cli->oplock_handler = cli_oplock_ack;
        cli->case_sensitive = False;
 
index 7816ed0fc6e57583baef3f229dbe37834df3286a..9d20ed3adcd268ca01629982c13b7bf3562aba5e 100644 (file)
@@ -1351,7 +1351,7 @@ int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path)
                pstring path2;
                clistr_pull(cli, path2, p, 
                            sizeof(path2), len, STR_ASCII);
-               *tmp_path = strdup(path2);
+               *tmp_path = SMB_STRDUP(path2);
        }
 
        return SVAL(cli->inbuf,smb_vwv0);
@@ -1402,7 +1402,7 @@ static BOOL cli_set_ea(struct cli_state *cli, uint16 setup, char *param, unsigne
        size_t ea_namelen = strlen(ea_name);
 
        data_len = 4 + 4 + ea_namelen + 1 + ea_len;
-       data = malloc(data_len);
+       data = SMB_MALLOC(data_len);
        if (!data) {
                return False;
        }
@@ -1558,7 +1558,7 @@ static BOOL cli_get_ea_list(struct cli_state *cli,
                goto out;
        }
 
-       ea_list = (struct ea_struct *)talloc(ctx, num_eas*sizeof(struct ea_struct));
+       ea_list = TALLOC_ARRAY(ctx, struct ea_struct, num_eas);
        if (!ea_list) {
                goto out;
        }
index ab157d48e963cad0e5be50482df18685950cdf74..8ab5854c8fb2ed6769fc99c20b5b80a781e2c278 100644 (file)
@@ -282,7 +282,7 @@ int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
                }
  
                /* and add them to the dirlist pool */
-               tdl = Realloc(dirlist,dirlist_len + data_len);
+               tdl = SMB_REALLOC(dirlist,dirlist_len + data_len);
 
                if (!tdl) {
                        DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
@@ -413,7 +413,7 @@ int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
 
                first = False;
 
-               tdl = Realloc(dirlist,(num_received + received)*DIR_STRUCT_SIZE);
+               tdl = SMB_REALLOC(dirlist,(num_received + received)*DIR_STRUCT_SIZE);
 
                if (!tdl) {
                        DEBUG(0,("cli_list_old: failed to expand dirlist"));
index af8b4422b78f8ceec5ffffe35c073b8c42c60580..25c36c214fc006ca29f4a0da92011491230f9fd8 100644 (file)
@@ -321,12 +321,12 @@ BOOL cli_list_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_LIST
                        goto cleanup;
                }
 
-               if ((tmp_list_ent=(SMB_NTQUOTA_LIST *)talloc_zero(mem_ctx,sizeof(SMB_NTQUOTA_LIST)))==NULL) {
+               if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
                        DEBUG(0,("talloc_zero() failed\n"));
                        return (-1);
                }
 
-               if ((tmp_list_ent->quotas=(SMB_NTQUOTA_STRUCT *)talloc_zero(mem_ctx,sizeof(SMB_NTQUOTA_STRUCT)))==NULL) {
+               if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
                        DEBUG(0,("talloc_zero() failed\n"));
                        return (-1);
                }
@@ -379,13 +379,13 @@ BOOL cli_list_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_LIST
                                goto cleanup;
                        }
 
-                       if ((tmp_list_ent=(SMB_NTQUOTA_LIST *)talloc_zero(mem_ctx,sizeof(SMB_NTQUOTA_LIST)))==NULL) {
+                       if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
                                DEBUG(0,("talloc_zero() failed\n"));
                                talloc_destroy(mem_ctx);
                                goto cleanup;
                        }
        
-                       if ((tmp_list_ent->quotas=(SMB_NTQUOTA_STRUCT *)talloc_zero(mem_ctx,sizeof(SMB_NTQUOTA_STRUCT)))==NULL) {
+                       if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
                                DEBUG(0,("talloc_zero() failed\n"));
                                talloc_destroy(mem_ctx);
                                goto cleanup;
index d1a23d36c8b0cc568f5afdba1312401492494a2b..3223098820486d2aac59a1ce5348fe8da466ba83 100644 (file)
@@ -256,8 +256,8 @@ static BOOL cli_issue_write(struct cli_state *cli, int fnum, off_t offset,
        BOOL bigoffset = False;
 
        if (size > cli->bufsize) {
-               cli->outbuf = realloc(cli->outbuf, size + 1024);
-               cli->inbuf = realloc(cli->inbuf, size + 1024);
+               cli->outbuf = SMB_REALLOC(cli->outbuf, size + 1024);
+               cli->inbuf = SMB_REALLOC(cli->inbuf, size + 1024);
                if (cli->outbuf == NULL || cli->inbuf == NULL)
                        return False;
                cli->bufsize = size + 1024;
index ae44ca1a779959f0c9e10fbd874d84e0b460a7a5..761741a91bc91442e38c1b740628af7191e9826a 100644 (file)
@@ -210,7 +210,7 @@ BOOL cli_receive_trans(struct cli_state *cli,int trans,
 
        /* allocate it */
        if (total_data!=0) {
-               tdata = Realloc(*data,total_data);
+               tdata = SMB_REALLOC(*data,total_data);
                if (!tdata) {
                        DEBUG(0,("cli_receive_trans: failed to enlarge data buffer\n"));
                        cli_signing_trans_stop(cli);
@@ -221,7 +221,7 @@ BOOL cli_receive_trans(struct cli_state *cli,int trans,
        }
 
        if (total_param!=0) {
-               tparam = Realloc(*param,total_param);
+               tparam = SMB_REALLOC(*param,total_param);
                if (!tparam) {
                        DEBUG(0,("cli_receive_trans: failed to enlarge param buffer\n"));
                        cli_signing_trans_stop(cli);
@@ -527,7 +527,7 @@ BOOL cli_receive_nt_trans(struct cli_state *cli,
 
        /* allocate it */
        if (total_data) {
-               tdata = Realloc(*data,total_data);
+               tdata = SMB_REALLOC(*data,total_data);
                if (!tdata) {
                        DEBUG(0,("cli_receive_nt_trans: failed to enlarge data buffer to %d\n",total_data));
                        cli_signing_trans_stop(cli);
@@ -538,7 +538,7 @@ BOOL cli_receive_nt_trans(struct cli_state *cli,
        }
 
        if (total_param) {
-               tparam = Realloc(*param,total_param);
+               tparam = SMB_REALLOC(*param,total_param);
                if (!tparam) {
                        DEBUG(0,("cli_receive_nt_trans: failed to enlarge param buffer to %d\n", total_param));
                        cli_signing_trans_stop(cli);
index 15cc75b129e6b64019b894ef06834da22f6ab2ee..fe863db422afa18c5c07dbd52c6d387c959d969e 100644 (file)
@@ -115,8 +115,7 @@ void add_failed_connection_entry(const char *domain, const char *server, NTSTATU
 
        /* Create negative lookup cache entry for this domain and controller */
 
-       if ( !(fcc = (struct failed_connection_cache *)malloc(sizeof(struct failed_connection_cache))) ) 
-       {
+       if ( !(fcc = SMB_MALLOC_P(struct failed_connection_cache)) ) {
                DEBUG(0, ("malloc failed in add_failed_connection_entry!\n"));
                return;
        }
index caf226c5a6a2d3e2573b14deb89a1716074f2f8b..ddb27535233abc12488d12085a0b365f6c41dda1 100644 (file)
@@ -55,7 +55,7 @@ static int smbc_add_cached_server(SMBCCTX * context, SMBCSRV * new,
 {
        struct smbc_server_cache * srvcache = NULL;
 
-       if (!(srvcache = malloc(sizeof(*srvcache)))) {
+       if (!(srvcache = SMB_MALLOC_P(struct smbc_server_cache))) {
                errno = ENOMEM;
                DEBUG(3, ("Not enough space for server cache allocation\n"));
                return 1;
@@ -65,25 +65,25 @@ static int smbc_add_cached_server(SMBCCTX * context, SMBCSRV * new,
 
        srvcache->server = new;
 
-       srvcache->server_name = strdup(server);
+       srvcache->server_name = SMB_STRDUP(server);
        if (!srvcache->server_name) {
                errno = ENOMEM;
                goto failed;
        }
 
-       srvcache->share_name = strdup(share);
+       srvcache->share_name = SMB_STRDUP(share);
        if (!srvcache->share_name) {
                errno = ENOMEM;
                goto failed;
        }
 
-       srvcache->workgroup = strdup(workgroup);
+       srvcache->workgroup = SMB_STRDUP(workgroup);
        if (!srvcache->workgroup) {
                errno = ENOMEM;
                goto failed;
        }
 
-       srvcache->username = strdup(username);
+       srvcache->username = SMB_STRDUP(username);
        if (!srvcache->username) {
                errno = ENOMEM;
                goto failed;
index c4be848cc17f90ca7c927ed1f2afe56377164d26..83088a14defcbc5f0fe9fd282cdb50cf41a8ede0 100644 (file)
@@ -73,7 +73,7 @@ static int add_fd(SMBCFILE * file)
                         return -1;
                 }
 
-                f = malloc(sizeof(struct smbc_compat_fdlist));
+                f = SMB_MALLOC_P(struct smbc_compat_fdlist);
                 if (!f) {
                         errno = ENOMEM;
                         return -1;
index 3dec0c92b4860e40c6a31b3361c3a97277b2efd2..df9c4ddcadcd8866df60fc473c8028124f295a68 100644 (file)
@@ -99,7 +99,7 @@ decode_urlpart(char *segment, size_t sizeof_segment)
     }
 
     /* make a copy of the old one */
-    new_usegment = (char*)malloc( old_length * 3 + 1 );
+    new_usegment = (char*)SMB_MALLOC( old_length * 3 + 1 );
 
     while( i < old_length ) {
        int bReencode = False;
@@ -671,7 +671,7 @@ SMBCSRV *smbc_server(SMBCCTX *context,
         * Let's find a free server_fd 
         */
 
-       srv = (SMBCSRV *)malloc(sizeof(*srv));
+       srv = SMB_MALLOC_P(SMBCSRV);
        if (!srv) {
                errno = ENOMEM;
                goto failed;
@@ -776,7 +776,7 @@ SMBCSRV *smbc_attr_server(SMBCCTX *context,
                         return NULL;
                 }
 
-                ipc_srv = (SMBCSRV *)malloc(sizeof(*ipc_srv));
+                ipc_srv = SMB_MALLOC_P(SMBCSRV);
                 if (!ipc_srv) {
                         errno = ENOMEM;
                         cli_shutdown(ipc_cli);
@@ -871,7 +871,7 @@ static SMBCFILE *smbc_open_ctx(SMBCCTX *context, const char *fname, int flags, m
        }
        else {
          
-               file = malloc(sizeof(SMBCFILE));
+               file = SMB_MALLOC_P(SMBCFILE);
 
                if (!file) {
 
@@ -895,7 +895,7 @@ static SMBCFILE *smbc_open_ctx(SMBCCTX *context, const char *fname, int flags, m
                /* Fill in file struct */
 
                file->cli_fd  = fd;
-               file->fname   = strdup(fname);
+               file->fname   = SMB_STRDUP(fname);
                file->srv     = srv;
                file->offset  = 0;
                file->file    = True;
@@ -1629,7 +1629,7 @@ static int add_dirent(SMBCFILE *dir, const char *name, const char *comment, uint
 
        size = sizeof(struct smbc_dirent) + u_name_len + u_comment_len + 1;
     
-       dirent = malloc(size);
+       dirent = SMB_MALLOC(size);
 
        if (!dirent) {
 
@@ -1642,7 +1642,7 @@ static int add_dirent(SMBCFILE *dir, const char *name, const char *comment, uint
 
        if (dir->dir_list == NULL) {
 
-               dir->dir_list = malloc(sizeof(struct smbc_dir_list));
+               dir->dir_list = SMB_MALLOC_P(struct smbc_dir_list);
                if (!dir->dir_list) {
 
                        SAFE_FREE(dirent);
@@ -1656,7 +1656,7 @@ static int add_dirent(SMBCFILE *dir, const char *name, const char *comment, uint
        }
        else {
 
-               dir->dir_end->next = malloc(sizeof(struct smbc_dir_list));
+               dir->dir_end->next = SMB_MALLOC_P(struct smbc_dir_list);
                
                if (!dir->dir_end->next) {
                        
@@ -1835,7 +1835,7 @@ static SMBCFILE *smbc_opendir_ctx(SMBCCTX *context, const char *fname)
 
        pstrcpy(workgroup, context->workgroup);
 
-       dir = malloc(sizeof(*dir));
+       dir = SMB_MALLOC_P(SMBCFILE);
 
        if (!dir) {
 
@@ -1847,7 +1847,7 @@ static SMBCFILE *smbc_opendir_ctx(SMBCCTX *context, const char *fname)
        ZERO_STRUCTP(dir);
 
        dir->cli_fd   = 0;
-       dir->fname    = strdup(fname);
+       dir->fname    = SMB_STRDUP(fname);
        dir->srv      = NULL;
        dir->offset   = 0;
        dir->file     = False;
@@ -3110,7 +3110,7 @@ static BOOL add_ace(SEC_ACL **the_acl, SEC_ACE *ace, TALLOC_CTX *ctx)
                return True;
        }
 
-       aces = calloc(1+(*the_acl)->num_aces,sizeof(SEC_ACE));
+       aces = SMB_CALLOC_ARRAY(SEC_ACE, 1+(*the_acl)->num_aces);
        memcpy(aces, (*the_acl)->ace, (*the_acl)->num_aces * sizeof(SEC_ACE));
        memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
        new = make_sec_acl(ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
@@ -3143,7 +3143,7 @@ static SEC_DESC *sec_desc_parse(TALLOC_CTX *ctx,
                }
 
                if (StrnCaseCmp(tok,"OWNER:", 6) == 0) {
-                       owner_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
+                       owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
                        if (!owner_sid ||
                            !convert_string_to_sid(ipc_cli, pol,
                                                    numeric,
@@ -3155,7 +3155,7 @@ static SEC_DESC *sec_desc_parse(TALLOC_CTX *ctx,
                }
 
                if (StrnCaseCmp(tok,"OWNER+:", 7) == 0) {
-                       owner_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
+                       owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
                        if (!owner_sid ||
                            !convert_string_to_sid(ipc_cli, pol,
                                                    False,
@@ -3167,7 +3167,7 @@ static SEC_DESC *sec_desc_parse(TALLOC_CTX *ctx,
                }
 
                if (StrnCaseCmp(tok,"GROUP:", 6) == 0) {
-                       grp_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
+                       grp_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
                        if (!grp_sid ||
                            !convert_string_to_sid(ipc_cli, pol,
                                                    numeric,
@@ -3179,7 +3179,7 @@ static SEC_DESC *sec_desc_parse(TALLOC_CTX *ctx,
                }
 
                if (StrnCaseCmp(tok,"GROUP+:", 7) == 0) {
-                       grp_sid = (DOM_SID *)calloc(1, sizeof(DOM_SID));
+                       grp_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
                        if (!grp_sid ||
                            !convert_string_to_sid(ipc_cli, pol,
                                                    False,
@@ -4273,7 +4273,7 @@ SMBCCTX * smbc_new_context(void)
 {
         SMBCCTX * context;
 
-        context = malloc(sizeof(SMBCCTX));
+        context = SMB_MALLOC_P(SMBCCTX);
         if (!context) {
                 errno = ENOMEM;
                 return NULL;
@@ -4281,7 +4281,7 @@ SMBCCTX * smbc_new_context(void)
 
         ZERO_STRUCTP(context);
 
-        context->internal = malloc(sizeof(struct smbc_internal_data));
+        context->internal = SMB_MALLOC_P(struct smbc_internal_data);
         if (!context->internal) {
                 errno = ENOMEM;
                 return NULL;
@@ -4488,8 +4488,8 @@ SMBCCTX * smbc_init_context(SMBCCTX * context)
                  */
                 user = getenv("USER");
                 /* walk around as "guest" if no username can be found */
-                if (!user) context->user = strdup("guest");
-                else context->user = strdup(user);
+                if (!user) context->user = SMB_STRDUP("guest");
+                else context->user = SMB_STRDUP(user);
         }
 
         if (!context->netbios_name) {
@@ -4498,14 +4498,14 @@ SMBCCTX * smbc_init_context(SMBCCTX * context)
                  * back on constructing our netbios name from our hostname etc
                  */
                 if (global_myname()) {
-                        context->netbios_name = strdup(global_myname());
+                        context->netbios_name = SMB_STRDUP(global_myname());
                 }
                 else {
                         /*
                          * Hmmm, I want to get hostname as well, but I am too lazy for the moment
                          */
                         pid = sys_getpid();
-                        context->netbios_name = malloc(17);
+                        context->netbios_name = SMB_MALLOC(17);
                         if (!context->netbios_name) {
                                 errno = ENOMEM;
                                 return NULL;
@@ -4518,11 +4518,11 @@ SMBCCTX * smbc_init_context(SMBCCTX * context)
 
         if (!context->workgroup) {
                 if (lp_workgroup()) {
-                        context->workgroup = strdup(lp_workgroup());
+                        context->workgroup = SMB_STRDUP(lp_workgroup());
                 }
                 else {
                         /* TODO: Think about a decent default workgroup */
-                        context->workgroup = strdup("samba");
+                        context->workgroup = SMB_STRDUP("samba");
                 }
         }
 
index fef769314af399e3fc43ac33930f2b68defb7a95..e6868fb3730904d096262e91be26d6c57ad270b4 100644 (file)
@@ -55,7 +55,7 @@ static struct node_status *parse_node_status(char *p, int *num_names, struct nod
        if (*num_names == 0)
                return NULL;
 
-       ret = (struct node_status *)malloc(sizeof(struct node_status)* (*num_names));
+       ret = SMB_MALLOC_ARRAY(struct node_status,*num_names);
        if (!ret)
                return NULL;
 
@@ -478,8 +478,8 @@ struct in_addr *name_query(int fd,const char *name,int name_type,
                                continue;
                        }
                        
-                       tmp_ip_list = (struct in_addr *)Realloc( ip_list, sizeof( ip_list[0] )
-                                                                * ( (*count) + nmb2->answers->rdlength/6 ) );
+                       tmp_ip_list = SMB_REALLOC_ARRAY( ip_list, struct in_addr,
+                                               (*count) + nmb2->answers->rdlength/6 );
                        
                        if (!tmp_ip_list) {
                                DEBUG(0,("name_query: Realloc failed.\n"));
@@ -655,7 +655,7 @@ static BOOL convert_ip2service( struct ip_service **return_iplist, struct in_add
                return False;
                
        /* copy the ip address; port will be PORT_NONE */
-       if ( (*return_iplist = (struct ip_service*)malloc(count*sizeof(struct ip_service))) == NULL ) {
+       if ( (*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
                DEBUG(0,("convert_ip2service: malloc failed for %d enetries!\n", count ));
                return False;
        }
@@ -868,8 +868,8 @@ static BOOL resolve_lmhosts(const char *name, int name_type,
                if ((name_type2 != -1) && (name_type != name_type2))
                        continue;
 
-               *return_iplist = (struct ip_service *)realloc((*return_iplist),
-                       sizeof(struct ip_service) * ((*return_count)+1));
+               *return_iplist = SMB_REALLOC_ARRAY((*return_iplist), struct ip_service,
+                                       (*return_count)+1);
 
                if ((*return_iplist) == NULL) {
                        DEBUG(3,("resolve_lmhosts: malloc fail !\n"));
@@ -919,7 +919,7 @@ static BOOL resolve_hosts(const char *name, int name_type,
        if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) {
                struct in_addr return_ip;
                putip((char *)&return_ip,(char *)hp->h_addr);
-               *return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service));
+               *return_iplist = SMB_MALLOC_P(struct ip_service);
                if(*return_iplist == NULL) {
                        DEBUG(3,("resolve_hosts: malloc fail !\n"));
                        return False;
@@ -958,7 +958,7 @@ static BOOL resolve_ads(const char *name, int name_type,
                        return False;
                                
                count = count_chars(list, ' ') + 1;
-               if ( (*return_iplist = malloc(count * sizeof(struct ip_service))) == NULL ) {
+               if ( (*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
                        DEBUG(0,("resolve_hosts: malloc failed for %d entries\n", count ));
                        return False;
                }
@@ -1029,7 +1029,7 @@ BOOL internal_resolve_name(const char *name, int name_type,
 
        if (allzeros || allones || is_address) {
   
-               if ( (*return_iplist = (struct ip_service *)malloc(sizeof(struct ip_service))) == NULL ) {
+               if ( (*return_iplist = SMB_MALLOC_P(struct ip_service)) == NULL ) {
                        DEBUG(0,("internal_resolve_name: malloc fail !\n"));
                        return False;
                }
@@ -1333,8 +1333,7 @@ static BOOL get_dc_list(const char *domain, struct ip_service **ip_list,
                        return False;
                }
                
-               if ( (return_iplist = (struct ip_service *)
-                               malloc(num_addresses * sizeof(struct ip_service))) == NULL ) {
+               if ( (return_iplist = SMB_MALLOC_ARRAY(struct ip_service, num_addresses)) == NULL ) {
                        DEBUG(3,("get_dc_list: malloc fail !\n"));
                        return False;
                }
index 7f22ce0096afc6ff86186b87eb62d9a67a49b643..1c93f7b1e2bd15b36e236b4a46f926cfdabacefe 100644 (file)
@@ -354,7 +354,7 @@ static BOOL parse_alloc_res_rec(char *inbuf,int *offset,int length,
 {
        int i;
 
-       *recs = (struct res_rec *)malloc(sizeof(**recs)*count);
+       *recs = SMB_MALLOC_ARRAY(struct res_rec, count);
        if (!*recs)
                return(False);
 
@@ -557,7 +557,7 @@ static struct packet_struct *copy_nmb_packet(struct packet_struct *packet)
        struct nmb_packet *copy_nmb;
        struct packet_struct *pkt_copy;
 
-       if(( pkt_copy = (struct packet_struct *)malloc(sizeof(*packet))) == NULL) {
+       if(( pkt_copy = SMB_MALLOC_P(struct packet_struct)) == NULL) {
                DEBUG(0,("copy_nmb_packet: malloc fail.\n"));
                return NULL;
        }
@@ -580,22 +580,19 @@ static struct packet_struct *copy_nmb_packet(struct packet_struct *packet)
        /* Now copy any resource records. */
 
        if (nmb->answers) {
-               if((copy_nmb->answers = (struct res_rec *)
-                                       malloc(nmb->header.ancount * sizeof(struct res_rec))) == NULL)
+               if((copy_nmb->answers = SMB_MALLOC_ARRAY(struct res_rec,nmb->header.ancount)) == NULL)
                        goto free_and_exit;
                memcpy((char *)copy_nmb->answers, (char *)nmb->answers, 
                                nmb->header.ancount * sizeof(struct res_rec));
        }
        if (nmb->nsrecs) {
-               if((copy_nmb->nsrecs = (struct res_rec *)
-                                       malloc(nmb->header.nscount * sizeof(struct res_rec))) == NULL)
+               if((copy_nmb->nsrecs = SMB_MALLOC_ARRAY(struct res_rec, nmb->header.nscount)) == NULL)
                        goto free_and_exit;
                memcpy((char *)copy_nmb->nsrecs, (char *)nmb->nsrecs, 
                                nmb->header.nscount * sizeof(struct res_rec));
        }
        if (nmb->additional) {
-               if((copy_nmb->additional = (struct res_rec *)
-                                       malloc(nmb->header.arcount * sizeof(struct res_rec))) == NULL)
+               if((copy_nmb->additional = SMB_MALLOC_ARRAY(struct res_rec, nmb->header.arcount)) == NULL)
                        goto free_and_exit;
                memcpy((char *)copy_nmb->additional, (char *)nmb->additional, 
                                nmb->header.arcount * sizeof(struct res_rec));
@@ -622,7 +619,7 @@ static struct packet_struct *copy_dgram_packet(struct packet_struct *packet)
 { 
        struct packet_struct *pkt_copy;
 
-       if(( pkt_copy = (struct packet_struct *)malloc(sizeof(*packet))) == NULL) {
+       if(( pkt_copy = SMB_MALLOC_P(struct packet_struct)) == NULL) {
                DEBUG(0,("copy_dgram_packet: malloc fail.\n"));
                return NULL;
        }
@@ -700,7 +697,7 @@ struct packet_struct *parse_packet(char *buf,int length,
        struct packet_struct *p;
        BOOL ok=False;
 
-       p = (struct packet_struct *)malloc(sizeof(*p));
+       p = SMB_MALLOC_P(struct packet_struct);
        if (!p)
                return(NULL);
 
index 6e41a61bf1bb492eef497fce96731050cc5ae887..eb1fce5439202bd98f2213a0855096b369d15294 100644 (file)
@@ -766,7 +766,7 @@ NTSTATUS ntlmssp_server_start(NTLMSSP_STATE **ntlmssp_state)
 
        mem_ctx = talloc_init("NTLMSSP context");
        
-       *ntlmssp_state = talloc_zero(mem_ctx, sizeof(**ntlmssp_state));
+       *ntlmssp_state = TALLOC_ZERO_P(mem_ctx, NTLMSSP_STATE);
        if (!*ntlmssp_state) {
                DEBUG(0,("ntlmssp_server_start: talloc failed!\n"));
                talloc_destroy(mem_ctx);
@@ -1075,7 +1075,7 @@ NTSTATUS ntlmssp_client_start(NTLMSSP_STATE **ntlmssp_state)
 
        mem_ctx = talloc_init("NTLMSSP Client context");
        
-       *ntlmssp_state = talloc_zero(mem_ctx, sizeof(**ntlmssp_state));
+       *ntlmssp_state = TALLOC_ZERO_P(mem_ctx, NTLMSSP_STATE);
        if (!*ntlmssp_state) {
                DEBUG(0,("ntlmssp_client_start: talloc failed!\n"));
                talloc_destroy(mem_ctx);
index ed2283725c891f3f30c05920e60d11ae4faaa8dc..fdfc92a750a9d10fc3e4a707d60937f68817b0ac 100644 (file)
@@ -188,7 +188,7 @@ NET_USER_INFO_3* netsamlogon_cache_get( TALLOC_CTX *mem_ctx, const DOM_SID *user
        
        if ( data.dptr ) {
                
-               if ( (user = (NET_USER_INFO_3*)malloc(sizeof(NET_USER_INFO_3))) == NULL )
+               if ( (user = SMB_MALLOC_P(NET_USER_INFO_3)) == NULL )
                        return NULL;
                        
                prs_init( &ps, 0, mem_ctx, UNMARSHALL );
index b02a13c73e12f73738023c04da787a0696dad441..df69ff3e41f3e14be925cbe4262f44a7a9e4cb54 100644 (file)
@@ -54,7 +54,7 @@ static BOOL store_sequence_for_reply(struct outstanding_packet_lookup **list,
                }
        }
 
-       t = smb_xmalloc(sizeof(*t));
+       t = SMB_XMALLOC_P(struct outstanding_packet_lookup);
        ZERO_STRUCTP(t);
 
        t->mid = mid;
@@ -459,7 +459,7 @@ BOOL cli_simple_set_signing(struct cli_state *cli,
                return False;
        }
 
-       data = smb_xmalloc(sizeof(*data));
+       data = SMB_XMALLOC_P(struct smb_basic_signing_context);
        memset(data, '\0', sizeof(*data));
 
        cli->sign_info.signing_context = data;
@@ -509,7 +509,7 @@ void cli_signing_trans_start(struct cli_state *cli, uint16 mid)
        if (!cli->sign_info.doing_signing || !data)
                return;
 
-       data->trans_info = smb_xmalloc(sizeof(struct trans_info_context));
+       data->trans_info = SMB_XMALLOC_P(struct trans_info_context);
        ZERO_STRUCTP(data->trans_info);
 
        /* This ensures the sequence is pulled off the outstanding packet list */
@@ -982,7 +982,7 @@ void srv_signing_trans_start(uint16 mid)
        if (!data)
                return;
 
-       data->trans_info = smb_xmalloc(sizeof(struct trans_info_context));
+       data->trans_info = SMB_XMALLOC_P(struct trans_info_context);
        ZERO_STRUCTP(data->trans_info);
 
        data->trans_info->reply_seq_num = data->send_seq_num-1;
@@ -1051,7 +1051,7 @@ void srv_set_signing(const DATA_BLOB user_session_key, const DATA_BLOB response)
        
        srv_sign_info.doing_signing = True;
 
-       data = smb_xmalloc(sizeof(*data));
+       data = SMB_XMALLOC_P(struct smb_basic_signing_context);
        memset(data, '\0', sizeof(*data));
 
        srv_sign_info.signing_context = data;
index 50caf7b4c0e9d09b6016e45c25218f58b0cd5b02..a0f5565d4f3f9fbdff12a7e74dcbb1cf2aa95cbd 100644 (file)
@@ -42,12 +42,11 @@ static BOOL read_negTokenInit(ASN1_DATA *asn1, negTokenInit_t *token)
                        asn1_start_tag(asn1, ASN1_CONTEXT(0));
                        asn1_start_tag(asn1, ASN1_SEQUENCE(0));
 
-                       token->mechTypes = malloc(sizeof(*token->mechTypes));
+                       token->mechTypes = SMB_MALLOC_P(char *);
                        for (i = 0; !asn1->has_error &&
                                     0 < asn1_tag_remaining(asn1); i++) {
                                token->mechTypes = 
-                                       realloc(token->mechTypes, (i + 2) *
-                                               sizeof(*token->mechTypes));
+                                       SMB_REALLOC_ARRAY(token->mechTypes, char *, i + 2);
                                asn1_read_OID(asn1, token->mechTypes + i);
                        }
                        token->mechTypes[i] = NULL;
index 61144eb59a9c801fafe516e0354694a598359a04..d92027e267aa68ecd38f3122a5e43f535ac48946 100644 (file)
@@ -407,7 +407,7 @@ NTSTATUS brl_lock(SMB_DEV_T dev, SMB_INO_T ino, int fnum,
        }
 
        /* no conflicts - add it to the list of locks */
-       tp = Realloc(dbuf.dptr, dbuf.dsize + sizeof(*locks));
+       tp = SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(*locks));
        if (!tp) {
                status = NT_STATUS_NO_MEMORY;
                goto fail;
index d4e8c493d501f84cac37ba0364c5af9a5ae44b09..b2f30a5684375492bd2e416a093206a31263145a 100644 (file)
@@ -679,7 +679,7 @@ BOOL set_share_mode(files_struct *fsp, uint16 port, uint16 op_type)
                pstrcat(fname, fsp->fsp_name);
 
                size = sizeof(*data) + sizeof(share_mode_entry) + strlen(fname) + 1;
-               p = (char *)malloc(size);
+               p = (char *)SMB_MALLOC(size);
                if (!p)
                        return False;
                data = (struct locking_data *)p;
@@ -711,7 +711,7 @@ BOOL set_share_mode(files_struct *fsp, uint16 port, uint16 op_type)
                fsp->fsp_name, data->u.num_share_mode_entries ));
 
        size = dbuf.dsize + sizeof(share_mode_entry);
-       p = malloc(size);
+       p = SMB_MALLOC(size);
        if (!p) {
                SAFE_FREE(dbuf.dptr);
                return False;
@@ -1161,7 +1161,7 @@ BOOL add_deferred_open(uint16 mid, struct timeval *ptv, SMB_DEV_T dev, SMB_INO_T
                /* we'll need to create a new record */
 
                size = sizeof(*data) + sizeof(deferred_open_entry) + strlen(fname) + 1;
-               p = (char *)malloc(size);
+               p = (char *)SMB_MALLOC(size);
                if (!p)
                        return False;
                data = (struct deferred_open_data *)p;
@@ -1193,7 +1193,7 @@ BOOL add_deferred_open(uint16 mid, struct timeval *ptv, SMB_DEV_T dev, SMB_INO_T
                fname, data->u.num_deferred_open_entries ));
 
        size = dbuf.dsize + sizeof(deferred_open_entry);
-       p = malloc(size);
+       p = SMB_MALLOC(size);
        if (!p) {
                SAFE_FREE(dbuf.dptr);
                return False;
index 0e5edfa0eb8ba2f17e4f7bf699d90b78f7bc441c..6ab2ed377e2f998d55acb841aa0c321170f01d43 100644 (file)
@@ -102,7 +102,7 @@ static BOOL add_fd_to_close_entry(files_struct *fsp)
 
        dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 
-       tp = Realloc(dbuf.dptr, dbuf.dsize + sizeof(int));
+       tp = SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(int));
        if (!tp) {
                DEBUG(0,("add_fd_to_close_entry: Realloc fail !\n"));
                SAFE_FREE(dbuf.dptr);
@@ -371,7 +371,7 @@ static BOOL add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T s
        pl.size = size;
        pl.lock_type = lock_type;
 
-       tp = Realloc(dbuf.dptr, dbuf.dsize + sizeof(pl));
+       tp = SMB_REALLOC(dbuf.dptr, dbuf.dsize + sizeof(pl));
        if (!tp) {
                DEBUG(0,("add_posix_lock_entry: Realloc fail !\n"));
                goto fail;
@@ -896,8 +896,7 @@ BECOMES.....
         | l_curr|         | l_new   |
         +-------+         +---------+
 **********************************************/
-                               struct lock_list *l_new = (struct lock_list *)talloc(ctx,
-                                                                                                       sizeof(struct lock_list));
+                               struct lock_list *l_new = TALLOC_P(ctx, struct lock_list);
 
                                if(l_new == NULL) {
                                        DEBUG(0,("posix_lock_list: talloc fail.\n"));
@@ -1002,7 +1001,7 @@ BOOL set_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_cou
                return True; /* Not a fatal error. */
        }
 
-       if ((ll = (struct lock_list *)talloc(l_ctx, sizeof(struct lock_list))) == NULL) {
+       if ((ll = TALLOC_P(l_ctx, struct lock_list)) == NULL) {
                DEBUG(0,("set_posix_lock: unable to talloc unlock list.\n"));
                talloc_destroy(l_ctx);
                return True; /* Not a fatal error. */
@@ -1148,7 +1147,7 @@ BOOL release_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u
                return True; /* Not a fatal error. */
        }
 
-       if ((ul = (struct lock_list *)talloc(ul_ctx, sizeof(struct lock_list))) == NULL) {
+       if ((ul = TALLOC_P(ul_ctx, struct lock_list)) == NULL) {
                DEBUG(0,("release_posix_lock: unable to talloc unlock list.\n"));
                talloc_destroy(ul_ctx);
                return True; /* Not a fatal error. */
index 68b8aad0ac55784b343095ec3bac002ec3d0312d..1b36914bbea7219e8448090dd6f0cf82c72fc99d 100644 (file)
@@ -126,16 +126,15 @@ static void atalk_add_to_list(name_compare_entry **list)
                }
        }
 
-       if (!(new_list = calloc(1, 
-         (count == 0 ? 1 : count + 1) * sizeof(name_compare_entry))))
+       if (!(new_list = SMB_CALLOC_ARRAY(name_compare_entry, (count == 0 ? 1 : count + 1))))
                return;
 
        for (i = 0; i < count; i ++) {
-               new_list[i].name    = strdup(cur_list[i].name);
+               new_list[i].name    = SMB_STRDUP(cur_list[i].name);
                new_list[i].is_wild = cur_list[i].is_wild;
        }
 
-       new_list[i].name    = strdup(APPLEDOUBLE);
+       new_list[i].name    = SMB_STRDUP(APPLEDOUBLE);
        new_list[i].is_wild = False;
 
        free_namearray(*list);
index 1cb1cb327b49f29a4b9a72dac7ce3a0b63e8994f..5ff7931c585fe8893733f5a23c02fb159bed052e 100644 (file)
@@ -215,12 +215,12 @@ static BOOL recycle_create_dir(vfs_handle_struct *handle, const char *dname)
 
        mode = S_IRUSR | S_IWUSR | S_IXUSR;
 
-       tmp_str = strdup(dname);
+       tmp_str = SMB_STRDUP(dname);
        ALLOC_CHECK(tmp_str, done);
        tok_str = tmp_str;
 
        len = strlen(dname)+1;
-       new_dir = (char *)malloc(len + 1);
+       new_dir = (char *)SMB_MALLOC(len + 1);
        ALLOC_CHECK(new_dir, done);
        *new_dir = '\0';
 
@@ -389,11 +389,11 @@ static int recycle_unlink(vfs_handle_struct *handle, connection_struct *conn, co
        base = strrchr(file_name, '/');
        if (base == NULL) {
                base = file_name;
-               path_name = strdup("/");
+               path_name = SMB_STRDUP("/");
                ALLOC_CHECK(path_name, done);
        }
        else {
-               path_name = strdup(file_name);
+               path_name = SMB_STRDUP(file_name);
                ALLOC_CHECK(path_name, done);
                path_name[base - file_name] = '\0';
                base++;
@@ -422,7 +422,7 @@ static int recycle_unlink(vfs_handle_struct *handle, connection_struct *conn, co
        if (recycle_keep_dir_tree(handle) == True) {
                asprintf(&temp_name, "%s/%s", repository, path_name);
        } else {
-               temp_name = strdup(repository);
+               temp_name = SMB_STRDUP(repository);
        }
        ALLOC_CHECK(temp_name, done);
 
index 88135c0aed14b0f77a89ed745993d2f98be0c685..133e8e9c647ed64ba60201846def0c85197b2dd0 100644 (file)
@@ -82,7 +82,7 @@ static DIR *shadow_copy_opendir(vfs_handle_struct *handle, connection_struct *co
                return NULL;
        }
 
-       dirp = (shadow_copy_Dir *)malloc(sizeof(shadow_copy_Dir));
+       dirp = SMB_MALLOC_P(shadow_copy_Dir);
        if (!dirp) {
                DEBUG(0,("shadow_copy_opendir: Out of memory\n"));
                SMB_VFS_NEXT_CLOSEDIR(handle,conn,p);
@@ -108,7 +108,7 @@ static DIR *shadow_copy_opendir(vfs_handle_struct *handle, connection_struct *co
 
                DEBUG(10,("shadow_copy_opendir: not hide [%s]\n",d->d_name));
 
-               r = (SMB_STRUCT_DIRENT *)Realloc(dirp->dirs,(dirp->num+1)*sizeof(SMB_STRUCT_DIRENT));
+               r = SMB_REALLOC_ARRAY(dirp->dirs,SMB_STRUCT_DIRENT, dirp->num+1);
                if (!r) {
                        DEBUG(0,("shadow_copy_opendir: Out of memory\n"));
                        break;
@@ -176,7 +176,7 @@ static int shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle, files_str
                        continue;
                }
 
-               tlabels = (SHADOW_COPY_LABEL *)talloc_realloc(shadow_copy_data->mem_ctx,
+               tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(shadow_copy_data->mem_ctx,
                                                                        shadow_copy_data->labels,
                                                                        (shadow_copy_data->num_volumes+1)*sizeof(SHADOW_COPY_LABEL));
                if (tlabels == NULL) {
index c536deb6f45e21525598146f6b90d1491733dc27..b928a8a7c5c377a121a2bf1c84e366e34e6bb0a6 100644 (file)
@@ -206,7 +206,7 @@ static void release_1d_name( struct subnet_record *subrec, const char *workgroup
                struct userdata_struct *userdata;
                size_t size = sizeof(struct userdata_struct) + sizeof(BOOL);
 
-               if((userdata = (struct userdata_struct *)malloc(size)) == NULL) {
+               if((userdata = (struct userdata_struct *)SMB_MALLOC(size)) == NULL) {
                        DEBUG(0,("release_1d_name: malloc fail.\n"));
                        return;
                }
@@ -545,7 +545,7 @@ in workgroup %s on subnet %s\n",
        subrec->work_changed = True;
 
        /* Setup the userdata_struct. */
-       if((userdata = (struct userdata_struct *)malloc(size)) == NULL) {
+       if((userdata = (struct userdata_struct *)SMB_MALLOC(size)) == NULL) {
                DEBUG(0,("become_local_master_browser: malloc fail.\n"));
                return;
        }
index c92513fae81a0221bff0abab3842fa976d94d27d..e8797a99d5136d3708ec2e6f08e281f88ad9a1e4 100644 (file)
@@ -87,7 +87,7 @@ struct browse_cache_record *create_browser_in_lmb_cache( const char *work_name,
        struct browse_cache_record *browc;
        time_t now = time( NULL );
 
-       browc = (struct browse_cache_record *)malloc( sizeof( *browc ) );
+       browc = SMB_MALLOC_P(struct browse_cache_record);
 
        if( NULL == browc ) {
                DEBUG( 0, ("create_browser_in_lmb_cache: malloc fail !\n") );
index 56ffdc2670f52a06f28611d1d036618f13ac630b..03234bb98fa014da07d8fa18439850831173955e 100644 (file)
@@ -324,7 +324,7 @@ static void find_domain_master_name_query_success(struct subnet_record *subrec,
        /* Setup the userdata_struct - this is copied so we can use
        a stack variable for this. */
 
-       if((userdata = (struct userdata_struct *)malloc(size)) == NULL) {
+       if((userdata = (struct userdata_struct *)SMB_MALLOC(size)) == NULL) {
                DEBUG(0, ("find_domain_master_name_query_success: malloc fail.\n"));
                return;
        }
index 9214594096c5cd5d63735d13568567670122d073..7fac8c25739b7f2c62c169c599982e115b2427df 100644 (file)
@@ -516,7 +516,7 @@ void process_name_query_request(struct subnet_record *subrec, struct packet_stru
                        if (namerec->data.num_ips == 1) {
                                prdata = rdata;
                        } else {
-                               if ((prdata = (char *)malloc( namerec->data.num_ips * 6 )) == NULL) {
+                               if ((prdata = (char *)SMB_MALLOC( namerec->data.num_ips * 6 )) == NULL) {
                                        DEBUG(0,("process_name_query_request: malloc fail !\n"));
                                        return;
                                }
index bb14ff7641ae8d7b50b97c37f7839015e5da79fc..bdb308a2ea02c8f6c6bfa148387c4f9867d094d0 100644 (file)
@@ -181,14 +181,14 @@ struct name_record *add_name_to_subnet( struct subnet_record *subrec,
        struct name_record *namerec;
        time_t time_now = time(NULL);
 
-       namerec = (struct name_record *)malloc( sizeof(*namerec) );
+       namerec = SMB_MALLOC_P(struct name_record);
        if( NULL == namerec ) {
                DEBUG( 0, ( "add_name_to_subnet: malloc fail.\n" ) );
                return( NULL );
        }
 
        memset( (char *)namerec, '\0', sizeof(*namerec) );
-       namerec->data.ip = (struct in_addr *)malloc( sizeof(struct in_addr) * num_ips );
+       namerec->data.ip = SMB_MALLOC_ARRAY( struct in_addr, num_ips );
        if( NULL == namerec->data.ip ) {
                DEBUG( 0, ( "add_name_to_subnet: malloc fail when creating ip_flgs.\n" ) );
                ZERO_STRUCTP(namerec);
@@ -329,7 +329,7 @@ void add_ip_to_name_record( struct name_record *namerec, struct in_addr new_ip )
        if( find_ip_in_name_record( namerec, new_ip ) )
                return;
   
-       new_list = (struct in_addr *)malloc( (namerec->data.num_ips + 1) * sizeof(struct in_addr) );
+       new_list = SMB_MALLOC_ARRAY( struct in_addr, namerec->data.num_ips + 1);
        if( NULL == new_list ) {
                DEBUG(0,("add_ip_to_name_record: Malloc fail !\n"));
                return;
@@ -460,7 +460,7 @@ void add_samba_names_to_subnet( struct subnet_record *subrec )
                /* Create an IP list containing all our known subnets. */
 
                num_ips = iface_count();
-               iplist = (struct in_addr *)malloc( num_ips * sizeof(struct in_addr) );
+               iplist = SMB_MALLOC_ARRAY( struct in_addr, num_ips);
                if( NULL == iplist ) {
                        DEBUG(0,("add_samba_names_to_subnet: Malloc fail !\n"));
                        return;
index 4e11881f063876ed905bf9bf1a65ea1801102bef..8f2a88925421c96b15b55d49b6f96b93f12ef9eb 100644 (file)
@@ -306,7 +306,7 @@ static void multihomed_register_one(struct nmb_name *nmbname,
        struct in_addr wins_ip = wins_srv_ip_tag(tag, ip);
        fstring ip_str;
 
-       userdata = (struct userdata_struct *)malloc(sizeof(*userdata) + strlen(tag) + 1);
+       userdata = (struct userdata_struct *)SMB_MALLOC(sizeof(*userdata) + strlen(tag) + 1);
        if (!userdata) {
                DEBUG(0,("Failed to allocate userdata structure!\n"));
                return;
@@ -423,7 +423,7 @@ static void multihomed_register_name(struct nmb_name *nmbname, uint16 nb_flags,
        for(subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec) )
                num_ips++;
        
-       if((ip_list = (struct in_addr *)malloc(num_ips * sizeof(struct in_addr)))==NULL) {
+       if((ip_list = SMB_MALLOC_ARRAY(struct in_addr, num_ips))==NULL) {
                DEBUG(0,("multihomed_register_name: malloc fail !\n"));
                return;
        }
index a81b28ec7407414466411cf09b72d7dd93f51dcc..8a111eb957a2d2392929b947491be66b8bcf83eb 100644 (file)
@@ -184,7 +184,7 @@ static struct packet_struct *create_and_init_netbios_packet(struct nmb_name *nmb
        struct nmb_packet *nmb = NULL;
 
        /* Allocate the packet_struct we will return. */
-       if((packet = (struct packet_struct *)malloc(sizeof(*packet))) == NULL) {
+       if((packet = SMB_MALLOC_P(struct packet_struct)) == NULL) {
                DEBUG(0,("create_and_init_netbios_packet: malloc fail (1) for packet struct.\n"));
                return NULL;
        }
@@ -230,7 +230,7 @@ static BOOL create_and_init_additional_record(struct packet_struct *packet,
 {
        struct nmb_packet *nmb = &packet->packet.nmb;
 
-       if((nmb->additional = (struct res_rec *)malloc(sizeof(struct res_rec))) == NULL) {
+       if((nmb->additional = SMB_MALLOC_P(struct res_rec)) == NULL) {
                DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
                return False;
        }
@@ -534,7 +534,7 @@ void queue_wins_refresh(struct nmb_name *nmbname,
        DEBUG(6,("Refreshing name %s IP %s with WINS server %s using tag '%s'\n",
                 nmb_namestr(nmbname), ip_str, inet_ntoa(wins_ip), tag));
 
-       userdata = (struct userdata_struct *)malloc(sizeof(*userdata) + strlen(tag) + 1);
+       userdata = (struct userdata_struct *)SMB_MALLOC(sizeof(*userdata) + strlen(tag) + 1);
        if (!userdata) {
                DEBUG(0,("Failed to allocate userdata structure!\n"));
                return;
@@ -1645,7 +1645,7 @@ static BOOL create_listen_fdset(fd_set **ppset, int **psock_array, int *listen_n
        struct subnet_record *subrec = NULL;
        int count = 0;
        int num = 0;
-       fd_set *pset = (fd_set *)malloc(sizeof(fd_set));
+       fd_set *pset = SMB_MALLOC_P(fd_set);
 
        if(pset == NULL) {
                DEBUG(0,("create_listen_fdset: malloc fail !\n"));
@@ -1662,7 +1662,7 @@ only use %d.\n", (count*2) + 2, FD_SETSIZE));
                return True;
        }
 
-       if((sock_array = (int *)malloc(((count*2) + 2)*sizeof(int))) == NULL) {
+       if((sock_array = SMB_MALLOC_ARRAY(int, (count*2) + 2)) == NULL) {
                DEBUG(0,("create_listen_fdset: malloc fail for socket array.\n"));
                return True;
        }
index ae4011eb8f0414be48c32a3b682c8d225b3a63da..5c0fc2c521c2b724acb81915297761c65f346357 100644 (file)
@@ -577,8 +577,7 @@ reporting %s domain %s 0x%x ntversion=%x lm_nt token=%x lm_20 token=%x\n",
                                        return;
                                }
 
-                               db_info = (struct sam_database_info *)
-                                               malloc(sizeof(struct sam_database_info) * db_count);
+                               db_info = SMB_MALLOC_ARRAY(struct sam_database_info, db_count);
 
                                if (db_info == NULL) {
                                        DEBUG(3, ("out of memory allocating info for %d databases\n", db_count));
index 30c0c129508da9ef5b4a7d2026c979496905f3a8..a5903ef462ed9decd3b833b46f9503a5c3f50c62 100644 (file)
@@ -105,7 +105,7 @@ struct response_record *make_response_record( struct subnet_record *subrec,
        struct response_record *rrec;
        struct nmb_packet *nmb = &p->packet.nmb;
 
-       if (!(rrec = (struct response_record *)malloc(sizeof(*rrec)))) {
+       if (!(rrec = SMB_MALLOC_P(struct response_record))) {
                DEBUG(0,("make_response_queue_record: malloc fail for response_record.\n"));
                return NULL;
        }
@@ -133,7 +133,7 @@ struct response_record *make_response_record( struct subnet_record *subrec,
                } else {
                        /* Primitive userdata, do a memcpy. */
                        if((rrec->userdata = (struct userdata_struct *)
-                                       malloc(sizeof(struct userdata_struct)+userdata->userdata_len)) == NULL) {
+                                       SMB_MALLOC(sizeof(struct userdata_struct)+userdata->userdata_len)) == NULL) {
                                DEBUG(0,("make_response_queue_record: malloc fail for userdata.\n"));
                                ZERO_STRUCTP(rrec);
                                SAFE_FREE(rrec);
index e6fad8319d91a35395b7b90a6d39cfba812fd634..52d00e15854afe337b1c6c19f26e7b46decfc524 100644 (file)
@@ -137,7 +137,7 @@ workgroup %s. This is a bug.\n", name, work->work_group));
                return NULL;
        }
   
-       if((servrec = (struct server_record *)malloc(sizeof(*servrec))) == NULL) {
+       if((servrec = SMB_MALLOC_P(struct server_record)) == NULL) {
                DEBUG(0,("create_server_entry_on_workgroup: malloc fail !\n"));
                return NULL;
        }
index 02a91f27606026434d1a0087d3299c30d9600041..ecfd92719bf8eb25267a76e9ee893a206b24960f 100644 (file)
@@ -147,7 +147,7 @@ static struct subnet_record *make_subnet(const char *name, enum subnet_type type
                set_socket_options(dgram_sock,"SO_BROADCAST");
        }
 
-       subrec = (struct subnet_record *)malloc(sizeof(*subrec));
+       subrec = SMB_MALLOC_P(struct subnet_record);
        if (!subrec) {
                DEBUG(0,("make_subnet: malloc fail !\n"));
                close(nmb_sock);
@@ -160,7 +160,7 @@ static struct subnet_record *make_subnet(const char *name, enum subnet_type type
                        namelist_entry_compare,
                        ubi_trOVERWRITE );
 
-       if((subrec->subnet_name = strdup(name)) == NULL) {
+       if((subrec->subnet_name = SMB_STRDUP(name)) == NULL) {
                DEBUG(0,("make_subnet: malloc fail for subnet name !\n"));
                close(nmb_sock);
                close(dgram_sock);
index 86f1f760fd23029cd187c1241711d4278097bed5..c6bcb3e574284b862f2688530489344cf6b46657 100644 (file)
@@ -143,7 +143,7 @@ done:
                return;
        }
 
-       s = (struct sync_record *)malloc(sizeof(*s));
+       s = SMB_MALLOC_P(struct sync_record);
        if (!s) goto done;
 
        ZERO_STRUCTP(s);
index cce168adb2ff6e864b54fbe1fd6ef9a78ca5688c..b01ffcffc162393da927fd475ca443e909cee580 100644 (file)
@@ -59,7 +59,7 @@ returned for name %s.\n", nmb_namestr(nmbname) ));
        if(num_ips == 1) {
                iplist = &ip;
        } else {
-               if((iplist = (struct in_addr *)malloc( num_ips * sizeof(struct in_addr) )) == NULL) {
+               if((iplist = SMB_MALLOC_ARRAY( struct in_addr, num_ips )) == NULL) {
                        DEBUG(0,("wins_proxy_name_query_request_success: malloc fail !\n"));
                        return;
                }
@@ -131,7 +131,7 @@ proxy query returns.
 static struct userdata_struct *wins_proxy_userdata_copy_fn(struct userdata_struct *userdata)
 {
        struct packet_struct *p, *copy_of_p;
-       struct userdata_struct *new_userdata = (struct userdata_struct *)malloc( userdata->userdata_len );
+       struct userdata_struct *new_userdata = (struct userdata_struct *)SMB_MALLOC( userdata->userdata_len );
 
        if(new_userdata == NULL)
                return NULL;
index 0e0289d9a331c496b3137cd68065d212085c6b67..86f5b9c4261de1cd57b2ee206efd1003c1310596 100644 (file)
@@ -318,7 +318,7 @@ BOOL initialise_wins(void)
                }
 
                /* Allocate the space for the ip_list. */
-               if((ip_list = (struct in_addr *)malloc( num_ips * sizeof(struct in_addr))) == NULL) {
+               if((ip_list = SMB_MALLOC_ARRAY( struct in_addr, num_ips)) == NULL) {
                        DEBUG(0,("initialise_wins: Malloc fail !\n"));
                        return False;
                }
@@ -1379,7 +1379,7 @@ static void process_wins_dmb_query_request(struct subnet_record *subrec,
                return;
        }
 
-       if((prdata = (char *)malloc( num_ips * 6 )) == NULL) {
+       if((prdata = (char *)SMB_MALLOC( num_ips * 6 )) == NULL) {
                DEBUG(0,("process_wins_dmb_query_request: Malloc fail !.\n"));
                return;
        }
@@ -1442,7 +1442,7 @@ void send_wins_name_query_response(int rcode, struct packet_struct *p,
                if( namerec->data.num_ips == 1 ) {
                        prdata = rdata;
                } else {
-                       if((prdata = (char *)malloc( namerec->data.num_ips * 6 )) == NULL) {
+                       if((prdata = (char *)SMB_MALLOC( namerec->data.num_ips * 6 )) == NULL) {
                                DEBUG(0,("send_wins_name_query_response: malloc fail !\n"));
                                return;
                        }
index 8f3ae36b65d015e4b74a1fda68525f4367c3a984..917116dd07708ae6e4fe4460e49c99d384317876 100644 (file)
@@ -71,7 +71,7 @@ static struct work_record *create_workgroup(const char *name, int ttl)
        struct subnet_record *subrec;
        int t = -1;
   
-       if((work = (struct work_record *)malloc(sizeof(*work))) == NULL) {
+       if((work = SMB_MALLOC_P(struct work_record)) == NULL) {
                DEBUG(0,("create_workgroup: malloc fail !\n"));
                return NULL;
        }
index a1c71becf03d47700d6c34140441e2e3bcdb8352..3a920c1134b3cb3310c62d5f0575c5f2db960c41 100644 (file)
@@ -326,7 +326,7 @@ int winbind_initgroups(char *user, gid_t gid)
                /* Add group to list if necessary */
 
                if (!is_member) {
-                       tgr = (gid_t *)Realloc(groups, sizeof(gid_t) * ngroups + 1);
+                       tgr = SMB_REALLOC_ARRAY(groups, gid_t, ngroups + 1);
                        
                        if (!tgr) {
                                errno = ENOMEM;
index 455fb74f1716b426c71c066bc136366d70d76bcd..6f4a0a275335d089266fa54f29922748af908a59 100644 (file)
@@ -357,8 +357,7 @@ static void new_connection(int listen_sock, BOOL privileged)
        
        /* Create new connection structure */
        
-       if ((state = (struct winbindd_cli_state *) 
-             malloc(sizeof(*state))) == NULL)
+       if ((state = SMB_MALLOC_P(struct winbindd_cli_state)) == NULL)
                return;
        
        ZERO_STRUCTP(state);
index e6496695cb6aff283d87df22ee36aade7381f54e..2c8b7cae28755e43aef73e0dc087b3bee587920c 100644 (file)
@@ -219,7 +219,7 @@ static WINBINDD_GR* string2group( char *string )
                if ( num_gr_members ) {
                        fstring buffer;
                        
-                       gr_members = (char**)smb_xmalloc(sizeof(char*)*(num_gr_members+1));
+                       gr_members = SMB_XMALLOC_ARRAY(char*, num_gr_members+1);
                        
                        i = 0;
                        while ( next_token(&str, buffer, ",", sizeof(buffer)) && i<num_gr_members ) {
@@ -284,7 +284,7 @@ static char* group2string( const WINBINDD_GR *grp )
                        member = grp->gr_mem[num_members];
                }
                
-               gr_mem_str = smb_xmalloc(size);
+               gr_mem_str = SMB_XMALLOC_ARRAY(char, size);
        
                for ( i=0; i<num_members; i++ ) {
                        snprintf( &gr_mem_str[idx], size-idx, "%s,", grp->gr_mem[i] );
@@ -295,7 +295,7 @@ static char* group2string( const WINBINDD_GR *grp )
        }
        else {
                /* no members */
-               gr_mem_str = smb_xmalloc(sizeof(fstring));
+               gr_mem_str = SMB_XMALLOC_ARRAY(char, sizeof(fstring));
                fstrcpy( gr_mem_str, "" );
        }
 
@@ -639,7 +639,7 @@ static BOOL wb_addgrpmember( WINBINDD_GR *grp, const char *user )
        }
        
        /* add one new slot and keep an extra for the terminating NULL */
-       members = Realloc( grp->gr_mem, (grp->num_gr_mem+2)*sizeof(char*) );
+       members = SMB_REALLOC_ARRAY( grp->gr_mem, char *, grp->num_gr_mem+2);
        if ( !members )
                return False;
                
index 1392c96fb1e49681731dcb725b959e9ec3f81ebb..f77b76cd9abdc8fc74e5c535b5ef01a92cd673d0 100644 (file)
@@ -72,7 +72,7 @@ static ADS_STRUCT *ads_cached_connection(struct winbindd_domain *domain)
        ads->auth.password = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 
        SAFE_FREE(ads->auth.realm);
-       ads->auth.realm = strdup(lp_realm());
+       ads->auth.realm = SMB_STRDUP(lp_realm());
 
        status = ads_connect(ads);
        if (!ADS_ERR_OK(status) || !ads->config.realm) {
@@ -146,7 +146,7 @@ static NTSTATUS query_user_list(struct winbindd_domain *domain,
                goto done;
        }
 
-       (*info) = talloc_zero(mem_ctx, count * sizeof(**info));
+       (*info) = TALLOC_ZERO_ARRAY(mem_ctx, WINBIND_USERINFO, count);
        if (!*info) {
                status = NT_STATUS_NO_MEMORY;
                goto done;
@@ -179,7 +179,7 @@ static NTSTATUS query_user_list(struct winbindd_domain *domain,
                        continue;
                }
 
-               sid2 = talloc(mem_ctx, sizeof(*sid2));
+               sid2 = TALLOC_P(mem_ctx, DOM_SID);
                if (!sid2) {
                        status = NT_STATUS_NO_MEMORY;
                        goto done;
@@ -248,7 +248,7 @@ static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
                goto done;
        }
 
-       (*info) = talloc_zero(mem_ctx, count * sizeof(**info));
+       (*info) = TALLOC_ZERO_ARRAY(mem_ctx, struct acct_info, count);
        if (!*info) {
                status = NT_STATUS_NO_MEMORY;
                goto done;
@@ -421,7 +421,7 @@ static NTSTATUS query_user(struct winbindd_domain *domain,
                goto done;
        }
        
-       sid2 = talloc(mem_ctx, sizeof(*sid2));
+       sid2 = TALLOC_P(mem_ctx, DOM_SID);
        if (!sid2) {
                status = NT_STATUS_NO_MEMORY;
                goto done;
@@ -501,7 +501,7 @@ static NTSTATUS lookup_usergroups_alt(struct winbindd_domain *domain,
                goto done;
        }
        
-       (*user_gids) = talloc_zero(mem_ctx, sizeof(**user_gids) * (count + 1));
+       (*user_gids) = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID *, count + 1);
        (*user_gids)[0] = primary_group;
        
        *num_groups = 1;
@@ -516,7 +516,7 @@ static NTSTATUS lookup_usergroups_alt(struct winbindd_domain *domain,
                
                if (sid_equal(&group_sid, primary_group)) continue;
                
-               (*user_gids)[*num_groups] = talloc(mem_ctx, sizeof(***user_gids));
+               (*user_gids)[*num_groups] = TALLOC_P(mem_ctx, DOM_SID);
                if (!(*user_gids)[*num_groups]) {
                        status = NT_STATUS_NO_MEMORY;
                        goto done;
@@ -610,7 +610,7 @@ static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
                                             num_groups, user_gids);
        }
 
-       (*user_gids) = talloc_zero(mem_ctx, sizeof(**user_gids) * (count + 1));
+       (*user_gids) = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID *, count + 1);
        (*user_gids)[0] = primary_group;
        
        *num_groups = 1;
@@ -618,7 +618,7 @@ static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
        for (i=0;i<count;i++) {
                if (sid_equal(&sids[i], primary_group)) continue;
                
-               (*user_gids)[*num_groups] = talloc(mem_ctx, sizeof(***user_gids));
+               (*user_gids)[*num_groups] = TALLOC_P(mem_ctx, DOM_SID);
                if (!(*user_gids)[*num_groups]) {
                        status = NT_STATUS_NO_MEMORY;
                        goto done;
@@ -685,7 +685,7 @@ static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
        members = NULL;
        num_members = 0;
 
-       attrs = talloc(mem_ctx, 3 * sizeof(*attrs));
+       attrs = TALLOC_ARRAY(mem_ctx, const char *, 3);
        attrs[1] = talloc_strdup(mem_ctx, "usnChanged");
        attrs[2] = NULL;
                
@@ -751,9 +751,9 @@ static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
           the problem is that the members are in the form of distinguised names
        */
 
-       (*sid_mem) = talloc_zero(mem_ctx, sizeof(**sid_mem) * num_members);
-       (*name_types) = talloc_zero(mem_ctx, sizeof(**name_types) * num_members);
-       (*names) = talloc_zero(mem_ctx, sizeof(**names) * num_members);
+       (*sid_mem) = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID *, num_members);
+       (*name_types) = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_members);
+       (*names) = TALLOC_ZERO_ARRAY(mem_ctx, char *, num_members);
 
        for (i=0;i<num_members;i++) {
                uint32 name_type;
@@ -763,7 +763,7 @@ static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
                if (dn_lookup(ads, mem_ctx, members[i], &name, &name_type, &sid)) {
                    (*names)[*num_names] = name;
                    (*name_types)[*num_names] = name_type;
-                   (*sid_mem)[*num_names] = talloc(mem_ctx, sizeof(***sid_mem));
+                   (*sid_mem)[*num_names] = TALLOC_P(mem_ctx, DOM_SID);
                    if (!(*sid_mem)[*num_names]) {
                            status = NT_STATUS_NO_MEMORY;
                            goto done;
@@ -850,19 +850,19 @@ static NTSTATUS trusted_domains(struct winbindd_domain *domain,
        
                /* Allocate memory for trusted domain names and sids */
 
-               if ( !(*names = (char **)talloc(mem_ctx, sizeof(char *) * count)) ) {
+               if ( !(*names = TALLOC_ARRAY(mem_ctx, char *, count)) ) {
                        DEBUG(0, ("trusted_domains: out of memory\n"));
                        result = NT_STATUS_NO_MEMORY;
                        goto done;
                }
 
-               if ( !(*alt_names = (char **)talloc(mem_ctx, sizeof(char *) * count)) ) {
+               if ( !(*alt_names = TALLOC_ARRAY(mem_ctx, char *, count)) ) {
                        DEBUG(0, ("trusted_domains: out of memory\n"));
                        result = NT_STATUS_NO_MEMORY;
                        goto done;
                }
 
-               if ( !(*dom_sids = (DOM_SID *)talloc(mem_ctx, sizeof(DOM_SID) * count)) ) {
+               if ( !(*dom_sids = TALLOC_ARRAY(mem_ctx, DOM_SID, count)) ) {
                        DEBUG(0, ("trusted_domains: out of memory\n"));
                        result = NT_STATUS_NO_MEMORY;
                        goto done;
index a6ebafca965b94c1156590499537dbaf8bfa3755..ba274ec8e7060f1bec04086fbc38881b333e4dec 100644 (file)
@@ -136,7 +136,7 @@ static struct winbind_cache *get_cache(struct winbindd_domain *domain)
        if (ret)
                return ret;
        
-       ret = smb_xmalloc(sizeof(*ret));
+       ret = SMB_XMALLOC_P(struct winbind_cache);
        ZERO_STRUCTP(ret);
 
        wcache = ret;
@@ -209,7 +209,7 @@ static char *centry_string(struct cache_entry *centry, TALLOC_CTX *mem_ctx)
                smb_panic("centry_string");
        }
 
-       ret = talloc(mem_ctx, len+1);
+       ret = TALLOC(mem_ctx, len+1);
        if (!ret) {
                smb_panic("centry_string out of memory\n");
        }
@@ -227,7 +227,7 @@ static DOM_SID *centry_sid(struct cache_entry *centry, TALLOC_CTX *mem_ctx)
        DOM_SID *sid;
        char *sid_string;
 
-       sid = talloc(mem_ctx, sizeof(*sid));
+       sid = TALLOC_P(mem_ctx, DOM_SID);
        if (!sid)
                return NULL;
        
@@ -450,7 +450,7 @@ static struct cache_entry *wcache_fetch(struct winbind_cache *cache,
                return NULL;
        }
 
-       centry = smb_xmalloc(sizeof(*centry));
+       centry = SMB_XMALLOC_P(struct cache_entry);
        centry->data = (unsigned char *)data.dptr;
        centry->len = data.dsize;
        centry->ofs = 0;
@@ -501,7 +501,7 @@ static void centry_expand(struct cache_entry *centry, uint32 len)
        if (centry->len - centry->ofs >= len)
                return;
        centry->len *= 2;
-       p = realloc(centry->data, centry->len);
+       p = SMB_REALLOC(centry->data, centry->len);
        if (!p) {
                DEBUG(0,("out of memory: needed %d bytes in centry_expand\n", centry->len));
                smb_panic("out of memory in centry_expand");
@@ -568,10 +568,10 @@ struct cache_entry *centry_start(struct winbindd_domain *domain, NTSTATUS status
        if (!wcache->tdb)
                return NULL;
 
-       centry = smb_xmalloc(sizeof(*centry));
+       centry = SMB_XMALLOC_P(struct cache_entry);
 
        centry->len = 8192; /* reasonable default */
-       centry->data = smb_xmalloc(centry->len);
+       centry->data = SMB_XMALLOC_ARRAY(char, centry->len);
        centry->ofs = 0;
        centry->sequence_number = domain->sequence_number;
        centry_put_uint32(centry, NT_STATUS_V(status));
@@ -684,7 +684,7 @@ static NTSTATUS query_user_list(struct winbindd_domain *domain,
        if (*num_entries == 0)
                goto do_cached;
 
-       (*info) = talloc(mem_ctx, sizeof(**info) * (*num_entries));
+       (*info) = TALLOC_ARRAY(mem_ctx, WINBIND_USERINFO, *num_entries);
        if (! (*info))
                smb_panic("query_user_list out of memory");
        for (i=0; i<(*num_entries); i++) {
@@ -793,7 +793,7 @@ static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
        if (*num_entries == 0)
                goto do_cached;
 
-       (*info) = talloc(mem_ctx, sizeof(**info) * (*num_entries));
+       (*info) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_entries);
        if (! (*info))
                smb_panic("enum_dom_groups out of memory");
        for (i=0; i<(*num_entries); i++) {
@@ -866,7 +866,7 @@ static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
        if (*num_entries == 0)
                goto do_cached;
 
-       (*info) = talloc(mem_ctx, sizeof(**info) * (*num_entries));
+       (*info) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_entries);
        if (! (*info))
                smb_panic("enum_dom_groups out of memory");
        for (i=0; i<(*num_entries); i++) {
@@ -1156,7 +1156,7 @@ static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
        if (*num_groups == 0)
                goto do_cached;
 
-       (*user_gids) = talloc(mem_ctx, sizeof(**user_gids) * (*num_groups));
+       (*user_gids) = TALLOC_ARRAY(mem_ctx, DOM_SID *, *num_groups);
        if (! (*user_gids))
                smb_panic("lookup_usergroups out of memory");
        for (i=0; i<(*num_groups); i++) {
@@ -1227,9 +1227,9 @@ static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
        if (*num_names == 0)
                goto do_cached;
 
-       (*sid_mem) = talloc(mem_ctx, sizeof(**sid_mem) * (*num_names));
-       (*names) = talloc(mem_ctx, sizeof(**names) * (*num_names));
-       (*name_types) = talloc(mem_ctx, sizeof(**name_types) * (*num_names));
+       (*sid_mem) = TALLOC_ARRAY(mem_ctx, DOM_SID *, *num_names);
+       (*names) = TALLOC_ARRAY(mem_ctx, char *, *num_names);
+       (*name_types) = TALLOC_ARRAY(mem_ctx, uint32, *num_names);
 
        if (! (*sid_mem) || ! (*names) || ! (*name_types)) {
                smb_panic("lookup_groupmem out of memory");
index c9aef2905f254bdee3f3768d719647b7d4050cf6..1843ec188b03479bfa058f37e091b751f359e699 100644 (file)
@@ -432,7 +432,7 @@ static BOOL add_one_dc_unique(TALLOC_CTX *mem_ctx, const char *domain_name,
        if (!NT_STATUS_IS_OK(check_negative_conn_cache(domain_name, dcname)))
                return False;
 
-       *dcs = talloc_realloc(mem_ctx, *dcs, ((*num)+1) * sizeof(**dcs));
+       *dcs = TALLOC_REALLOC_ARRAY(mem_ctx, *dcs, struct dc_name_ip, (*num)+1);
 
        if (*dcs == NULL)
                return False;
@@ -448,7 +448,7 @@ static BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 {
        char *dup_str = talloc_strdup(mem_ctx, str);
 
-       *array = talloc_realloc(mem_ctx, *array, ((*num)+1) * sizeof(**array));
+       *array = TALLOC_REALLOC_ARRAY(mem_ctx, *array, char *, (*num)+1);
 
        if ((*array == NULL) || (dup_str == NULL))
                return False;
@@ -462,7 +462,7 @@ static BOOL add_sockaddr_to_array(TALLOC_CTX *mem_ctx,
                                  struct in_addr ip, uint16 port,
                                  struct sockaddr_in **addrs, int *num)
 {
-       *addrs = talloc_realloc(mem_ctx, *addrs, ((*num)+1) * sizeof(**addrs));
+       *addrs = TALLOC_REALLOC_ARRAY(mem_ctx, *addrs, struct sockaddr_in, (*num)+1);
 
        if (*addrs == NULL)
                return False;
@@ -753,7 +753,7 @@ static NTSTATUS new_cm_connection(struct winbindd_domain *domain, const char *pi
        struct winbindd_cm_conn *conn;
        NTSTATUS result;
 
-       if (!(conn = malloc(sizeof(*conn))))
+       if (!(conn = SMB_MALLOC_P(struct winbindd_cm_conn)))
                return NT_STATUS_NO_MEMORY;
                
        ZERO_STRUCTP(conn);
index d4ec6e586db29510a28252ac9de961ea3cf63492..587507ee29046c65960e87e07fc16e8b8538a957 100644 (file)
@@ -117,7 +117,7 @@ void dual_send_request(struct winbindd_cli_state *state)
 
        if (!background_process) return;
 
-       list = malloc(sizeof(*list));
+       list = SMB_MALLOC_P(struct dual_list);
        if (!list) return;
 
        list->next = NULL;
index 7eb0585c374f27385bb65ebbe6f3177131bbb543..4b49c1873e2425974512436faf3b1438e4010360 100644 (file)
@@ -47,7 +47,7 @@ static int gr_mem_buffer( char **buffer, char **members, int num_members )
        for ( i=0; i<num_members; i++ )
                len += strlen(members[i])+1;
 
-       *buffer = (char*)smb_xmalloc(len);
+       *buffer = SMB_XMALLOC_ARRAY(char, len);
        for ( i=0; i<num_members; i++ ) {
                snprintf( &(*buffer)[idx], len-idx, "%s,", members[i]);
                idx += strlen(members[i])+1;
@@ -194,7 +194,7 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain,
        /* Allocate buffer */
 
        if (!buf && buf_len != 0) {
-               if (!(buf = malloc(buf_len))) {
+               if (!(buf = SMB_MALLOC(buf_len))) {
                        DEBUG(1, ("out of memory\n"));
                        result = False;
                        goto done;
@@ -457,8 +457,7 @@ enum winbindd_result winbindd_setgrent(struct winbindd_cli_state *state)
                }
                                                
                
-               if ((domain_state = (struct getent_state *)
-                    malloc(sizeof(struct getent_state))) == NULL) {
+               if ((domain_state = SMB_MALLOC_P(struct getent_state)) == NULL) {
                        DEBUG(1, ("winbindd_setgrent: malloc failed for domain_state!\n"));
                        return WINBINDD_ERROR;
                }
@@ -542,7 +541,7 @@ static BOOL get_sam_group_entries(struct getent_state *ent)
        /* Copy entries into return buffer */
 
        if (num_entries) {
-               if ( !(name_list = malloc(sizeof(struct acct_info) * num_entries)) ) {
+               if ( !(name_list = SMB_MALLOC_ARRAY(struct acct_info, num_entries)) ) {
                        DEBUG(0,("get_sam_group_entries: Failed to malloc memory for %d domain groups!\n", 
                                num_entries));
                        result = False;
@@ -573,7 +572,7 @@ static BOOL get_sam_group_entries(struct getent_state *ent)
                /* Copy entries into return buffer */
 
                if ( num_entries ) {
-                       if ( !(tmp_name_list = Realloc( name_list, sizeof(struct acct_info) * (ent->num_sam_entries+num_entries))) )
+                       if ( !(tmp_name_list = SMB_REALLOC_ARRAY( name_list, struct acct_info, ent->num_sam_entries+num_entries)) )
                        {
                                DEBUG(0,("get_sam_group_entries: Failed to realloc more memory for %d local groups!\n", 
                                        num_entries));
@@ -625,8 +624,7 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
 
        num_groups = MIN(MAX_GETGRENT_GROUPS, state->request.data.num_entries);
 
-       if ((state->response.extra_data = 
-            malloc(num_groups * sizeof(struct winbindd_gr))) == NULL)
+       if ((state->response.extra_data = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups)) == NULL)
                return WINBINDD_ERROR;
 
        memset(state->response.extra_data, '\0',
@@ -746,9 +744,7 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
 
                if (result) {
                        /* Append to group membership list */
-                       new_gr_mem_list = Realloc(
-                               gr_mem_list,
-                               gr_mem_list_len + gr_mem_len);
+                       new_gr_mem_list = SMB_REALLOC( gr_mem_list, gr_mem_list_len + gr_mem_len);
 
                        if (!new_gr_mem_list && (group_list[group_list_ndx].num_gr_mem != 0)) {
                                DEBUG(0, ("out of memory\n"));
@@ -799,7 +795,7 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
        if (group_list_ndx == 0)
                goto done;
 
-       new_extra_data = Realloc(
+       new_extra_data = SMB_REALLOC(
                state->response.extra_data,
                group_list_ndx * sizeof(struct winbindd_gr) + gr_mem_list_len);
 
@@ -880,7 +876,7 @@ enum winbindd_result winbindd_list_groups(struct winbindd_cli_state *state)
                
                /* Allocate some memory for extra data.  Note that we limit
                   account names to sizeof(fstring) = 128 characters.  */               
-                ted = Realloc(extra_data, sizeof(fstring) * total_entries);
+                ted = SMB_REALLOC(extra_data, sizeof(fstring) * total_entries);
  
                if (!ted) {
                        DEBUG(0,("failed to enlarge buffer!\n"));
@@ -1151,12 +1147,12 @@ static void add_sid_to_parray_unique(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
                        return;
        }
 
-       *sids = talloc_realloc(mem_ctx, *sids, sizeof(**sids) * (*num_sids+1));
+       *sids = TALLOC_REALLOC_ARRAY(mem_ctx, *sids, DOM_SID *, *num_sids+1);
 
        if (*sids == NULL)
                return;
 
-       (*sids)[*num_sids] = talloc(mem_ctx, sizeof(DOM_SID));
+       (*sids)[*num_sids] = TALLOC_P(mem_ctx, DOM_SID);
        sid_copy((*sids)[*num_sids], sid);
        *num_sids += 1;
        return;
@@ -1259,7 +1255,7 @@ enum winbindd_result winbindd_getusersids(struct winbindd_cli_state *state)
        }
 
        /* build the reply */
-       ret = malloc(ret_size);
+       ret = SMB_MALLOC(ret_size);
        if (!ret) goto done;
        ofs = 0;
        for (i = 0; i < num_groups; i++) {
index 18478992f3e1714c43cdce3a909a237bbb29e08a..bb30a7029e16247b0d79f38698dad47ead6ca0be 100644 (file)
@@ -128,7 +128,7 @@ enum winbindd_result winbindd_list_trusted_domains(struct winbindd_cli_state
                /* Add domain to list */
 
                total_entries++;
-               ted = Realloc(extra_data, sizeof(fstring) * 
+               ted = SMB_REALLOC(extra_data, sizeof(fstring) * 
                               total_entries);
 
                if (!ted) {
@@ -168,7 +168,7 @@ enum winbindd_result winbindd_show_sequence(struct winbindd_cli_state *state)
        state->request.domain_name[sizeof(state->request.domain_name)-1]='\0';  
        which_domain = state->request.domain_name;
 
-       extra_data = strdup("");
+       extra_data = SMB_STRDUP("");
 
        /* this makes for a very simple data format, and is easily parsable as well
           if that is ever needed */
@@ -296,7 +296,7 @@ enum winbindd_result winbindd_priv_pipe_dir(struct winbindd_cli_state *state)
 
        DEBUG(3, ("[%5lu]: request location of privileged pipe\n", (unsigned long)state->pid));
        
-       state->response.extra_data = strdup(get_winbind_priv_pipe_dir());
+       state->response.extra_data = SMB_STRDUP(get_winbind_priv_pipe_dir());
        if (!state->response.extra_data)
                return WINBINDD_ERROR;
 
index e13649afe15085470919bf5d16f3c8aa6551bf7d..f7d3ac5aa41747ab8295edd5aa66d7c48127a852 100644 (file)
@@ -43,7 +43,7 @@ static NTSTATUS append_info3_as_ndr(TALLOC_CTX *mem_ctx,
        }
 
        size = prs_data_size(&ps);
-       state->response.extra_data = malloc(size);
+       state->response.extra_data = SMB_MALLOC(size);
        if (!state->response.extra_data) {
                prs_mem_free(&ps);
                return NT_STATUS_NO_MEMORY;
@@ -78,7 +78,7 @@ static NTSTATUS check_info3_in_group(TALLOC_CTX *mem_ctx,
                return NT_STATUS_INVALID_PARAMETER;
        }
 
-       all_sids = talloc(mem_ctx, sizeof(DOM_SID) * num_all_sids);
+       all_sids = TALLOC_ARRAY(mem_ctx, DOM_SID, num_all_sids);
        if (!all_sids)
                return NT_STATUS_NO_MEMORY;
 
@@ -363,7 +363,7 @@ done:
        if ( NT_STATUS_IS_OK(result) &&
             (state->request.flags & WBFLAG_PAM_AFS_TOKEN) ) {
 
-               char *afsname = strdup(lp_afs_username_map());
+               char *afsname = SMB_STRDUP(lp_afs_username_map());
                char *cell;
 
                if (afsname == NULL) goto no_token;
@@ -600,7 +600,7 @@ enum winbindd_result winbindd_pam_auth_crap(struct winbindd_cli_state *state)
 
                        DEBUG(5, ("Setting unix username to [%s]\n", username_out));
 
-                       state->response.extra_data = strdup(username_out);
+                       state->response.extra_data = SMB_STRDUP(username_out);
                        if (!state->response.extra_data) {
                                result = NT_STATUS_NO_MEMORY;
                                goto done;
index 3adb81caa354eaffc63ec5d455e91b3e705d5482..a208186b5f5205f0828ea1f96ff50dcae7ff47b5 100644 (file)
@@ -217,8 +217,7 @@ static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
                return NT_STATUS_OK;
        }
 
-       talloced_info = (struct acct_info *)
-               talloc_memdup(mem_ctx, *info,
+       talloced_info = (struct acct_info *)TALLOC_MEMDUP(mem_ctx, *info,
                              *num_entries * sizeof(struct acct_info));
 
        SAFE_FREE(*info);
@@ -332,15 +331,12 @@ static NTSTATUS trusted_domains(struct winbindd_domain *domain,
                nt_status = secrets_get_trusted_domains(mem_ctx, &enum_ctx, 1,
                                                        &num_sec_domains,
                                                        &domains);
-               *names = talloc_realloc(mem_ctx, *names,
-                                       sizeof(*names) *
-                                       (num_sec_domains + *num_domains));
-               *alt_names = talloc_realloc(mem_ctx, *alt_names,
-                                           sizeof(*alt_names) *
-                                           (num_sec_domains + *num_domains));
-               *dom_sids = talloc_realloc(mem_ctx, *dom_sids,
-                                          sizeof(**dom_sids) *
-                                          (num_sec_domains + *num_domains));
+               *names = TALLOC_REALLOC_ARRAY(mem_ctx, *names, char *,
+                                       num_sec_domains + *num_domains);
+               *alt_names = TALLOC_REALLOC_ARRAY(mem_ctx, *alt_names, char *,
+                                           num_sec_domains + *num_domains);
+               *dom_sids = TALLOC_REALLOC_ARRAY(mem_ctx, *dom_sids, DOM_SID,
+                                          num_sec_domains + *num_domains);
 
                for (i=0; i< num_sec_domains; i++) {
                        if (pull_ucs2_talloc(mem_ctx, &(*names)[*num_domains],
index ba24749fbef07cd036c48a9e6580d14d6148815f..de7f2ff76fbec30178b2b055a630b2c347afc471 100644 (file)
@@ -98,8 +98,7 @@ static NTSTATUS query_user_list(struct winbindd_domain *domain,
 
                *num_entries += num_dom_users;
 
-               *info = talloc_realloc( mem_ctx, *info, 
-                       (*num_entries) * sizeof(WINBIND_USERINFO));
+               *info = TALLOC_REALLOC_ARRAY( mem_ctx, *info, WINBIND_USERINFO, *num_entries);
 
                if (!(*info)) {
                        result = NT_STATUS_NO_MEMORY;
@@ -192,8 +191,7 @@ static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
                        break;
                }
 
-               (*info) = talloc_realloc(mem_ctx, *info, 
-                                        sizeof(**info) * ((*num_entries) + count));
+               (*info) = TALLOC_REALLOC_ARRAY(mem_ctx, *info, struct acct_info, (*num_entries) + count);
                if (! *info) {
                        talloc_destroy(mem_ctx2);
                        cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
@@ -255,8 +253,7 @@ static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
                        break;
                }
 
-               (*info) = talloc_realloc(mem_ctx, *info, 
-                                        sizeof(**info) * ((*num_entries) + count));
+               (*info) = TALLOC_REALLOC_ARRAY(mem_ctx, *info, struct acct_info, (*num_entries) + count);
                if (! *info) {
                        talloc_destroy(mem_ctx2);
                        cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
@@ -491,7 +488,7 @@ static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
                        
                *num_groups = user->num_groups;
                                
-               (*user_grpsids) = talloc(mem_ctx, sizeof(DOM_SID*) * (*num_groups));
+               (*user_grpsids) = TALLOC_ARRAY(mem_ctx, DOM_SID*, *num_groups);
                for (i=0;i<(*num_groups);i++) {
                        (*user_grpsids)[i] = rid_to_talloced_sid(domain, mem_ctx, user->gids[i].g_rid);
                }
@@ -543,7 +540,7 @@ static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
        if (!NT_STATUS_IS_OK(result) || (*num_groups) == 0)
                goto done;
 
-       (*user_grpsids) = talloc(mem_ctx, sizeof(DOM_SID*) * (*num_groups));
+       (*user_grpsids) = TALLOC_ARRAY(mem_ctx, DOM_SID *, *num_groups);
        if (!(*user_grpsids)) {
                result = NT_STATUS_NO_MEMORY;
                goto done;
@@ -643,9 +640,9 @@ static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
 
 #define MAX_LOOKUP_RIDS 900
 
-        *names = talloc_zero(mem_ctx, *num_names * sizeof(char *));
-        *name_types = talloc_zero(mem_ctx, *num_names * sizeof(uint32));
-        *sid_mem = talloc_zero(mem_ctx, *num_names * sizeof(DOM_SID *));
+        *names = TALLOC_ZERO_ARRAY(mem_ctx, char *, *num_names);
+        *name_types = TALLOC_ZERO_ARRAY(mem_ctx, uint32, *num_names);
+        *sid_mem = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID *, *num_names);
 
        for (j=0;j<(*num_names);j++) {
                (*sid_mem)[j] = rid_to_talloced_sid(domain, mem_ctx, (rid_mem)[j]);
index 249b9ccd8eb32d52952ded09709747fc3bf47df6..fc3fe0f9631791d4b1bd46c4ed89d9f081c33268 100644 (file)
@@ -351,8 +351,7 @@ enum winbindd_result winbindd_setpwent(struct winbindd_cli_state *state)
                                                
                /* Create a state record for this domain */
                 
-               if ((domain_state = (struct getent_state *)
-                    malloc(sizeof(struct getent_state))) == NULL)
+               if ((domain_state = SMB_MALLOC_P(struct getent_state)) == NULL)
                        return WINBINDD_ERROR;
                 
                ZERO_STRUCTP(domain_state);
@@ -429,10 +428,7 @@ static BOOL get_sam_user_entries(struct getent_state *ent)
        if (num_entries) {
                struct getpwent_user *tnl;
                
-               tnl = (struct getpwent_user *)Realloc(name_list, 
-                                                     sizeof(struct getpwent_user) *
-                                                     (ent->num_sam_entries + 
-                                                      num_entries));
+               tnl = SMB_REALLOC_ARRAY(name_list, struct getpwent_user, ent->num_sam_entries + num_entries);
                
                if (!tnl) {
                        DEBUG(0,("get_sam_user_entries realloc failed.\n"));
@@ -498,8 +494,7 @@ enum winbindd_result winbindd_getpwent(struct winbindd_cli_state *state)
 
        num_users = MIN(MAX_GETPWENT_USERS, state->request.data.num_entries);
        
-       if ((state->response.extra_data = 
-            malloc(num_users * sizeof(struct winbindd_pw))) == NULL)
+       if ((state->response.extra_data = SMB_MALLOC_ARRAY(struct winbindd_pw, num_users)) == NULL)
                return WINBINDD_ERROR;
 
        memset(state->response.extra_data, 0, num_users * 
@@ -624,7 +619,7 @@ enum winbindd_result winbindd_list_users(struct winbindd_cli_state *state)
                /* Allocate some memory for extra data */
                total_entries += num_entries;
                        
-               ted = Realloc(extra_data, sizeof(fstring) * total_entries);
+               ted = SMB_REALLOC(extra_data, sizeof(fstring) * total_entries);
                        
                if (!ted) {
                        DEBUG(0,("failed to enlarge buffer!\n"));
index a96f652c6172033fae7948004e726227080bfafb..7cbcba124535653ce5bc326b2897e4dbb4c39427 100644 (file)
@@ -139,7 +139,7 @@ static struct winbindd_domain *add_trusted_domain(const char *domain_name, const
         
        /* Create new domain entry */
 
-       if ((domain = (struct winbindd_domain *)malloc(sizeof(*domain))) == NULL)
+       if ((domain = SMB_MALLOC_P(struct winbindd_domain)) == NULL)
                return NULL;
 
        /* Fill in fields */
@@ -777,7 +777,7 @@ DOM_SID *rid_to_talloced_sid(struct winbindd_domain *domain,
                                    uint32 rid) 
 {
        DOM_SID *sid;
-       sid = talloc(mem_ctx, sizeof(*sid));
+       sid = TALLOC_P(mem_ctx, DOM_SID);
        if (!sid) {
                smb_panic("rid_to_to_talloced_sid: talloc for DOM_SID failed!\n");
        }
index 107c9d264cd538299834745ed1cbd50e9d7be41e..f199ebcb4371c97a5fcbb0168675558edbc2c01b 100644 (file)
@@ -97,7 +97,7 @@ static struct in_addr *lookup_byname_backend(const char *name, int *count)
        if (resolve_wins(name,0x20,&ret,count)) {
                if ( count == 0 )
                        return NULL;
-               if ( (return_ip = (struct in_addr *)malloc((*count)*sizeof(struct in_addr))) == NULL ) {
+               if ( (return_ip = SMB_MALLOC_ARRAY(struct in_addr, *count)) == NULL ) {
                        free( ret );
                        return NULL;
                }
index a1c4f4deec058c0e5291611b6403a196fec2dee1..8d26fc52971af77c903283a4617194136b4882ec 100644 (file)
@@ -101,7 +101,7 @@ static struct in_addr *lookup_byname_backend(const char *name, int *count)
 
        /* always try with wins first */
        if (resolve_wins(name,0x00,&address,count)) {
-               if ( (ret = (struct in_addr *)malloc(sizeof(struct in_addr))) == NULL ) {
+               if ( (ret = SMB_MALLOC_P(struct in_addr)) == NULL ) {
                        free( address );
                        return NULL;
                }
index 95f09c70e41b2355d8d8693e20cdc548eb0caddf..d0bad3ff171ec7d2dec07c19b861611231230ec2 100644 (file)
@@ -2262,9 +2262,7 @@ static int add_a_service(const service *pservice, const char *name)
        if (i == iNumServices) {
                service **tsp;
                
-               tsp = (service **) Realloc(ServicePtrs,
-                                          sizeof(service *) *
-                                          num_to_alloc);
+               tsp =&n