/**
Like strdup but for memory.
**/
-_PUBLIC_ void *memdup(const void *p, size_t size);
+_PUBLIC_ void *smb_memdup(const void *p, size_t size);
/**
* see if a range of memory is all zero. A NULL pointer is considered
/**
Like strdup but for memory.
**/
-_PUBLIC_ void *memdup(const void *p, size_t size);
+_PUBLIC_ void *smb_memdup(const void *p, size_t size);
/**
* Write a password to the log file.
Like strdup but for memory.
**/
-_PUBLIC_ void *memdup(const void *p, size_t size)
+_PUBLIC_ void *smb_memdup(const void *p, size_t size)
{
void *p2;
if (size == 0)
total_probed = get_interfaces(talloc_tos(), &ifaces);
if (total_probed > 0) {
- probed_ifaces = (struct iface_struct *)memdup(ifaces,
+ probed_ifaces = (struct iface_struct *)smb_memdup(ifaces,
sizeof(ifaces[0])*total_probed);
if (!probed_ifaces) {
- DEBUG(0,("ERROR: memdup failed\n"));
+ DEBUG(0,("ERROR: smb_memdup failed\n"));
exit(1);
}
}
mods[i]->mod_bvalues[j] = SMB_MALLOC_P(struct berval);
SMB_ASSERT(mods[i]->mod_bvalues[j] != NULL);
- mods[i]->mod_bvalues[j]->bv_val = (char *)memdup(blob->data, blob->length);
+ mods[i]->mod_bvalues[j]->bv_val = (char *)smb_memdup(blob->data, blob->length);
SMB_ASSERT(mods[i]->mod_bvalues[j]->bv_val != NULL);
mods[i]->mod_bvalues[j]->bv_len = blob->length;
* talloc
*/
- *rparam = (char *)memdup(my_rparam, num_my_rparam);
+ *rparam = (char *)smb_memdup(my_rparam, num_my_rparam);
if (*rparam == NULL) {
goto fail;
}
*rprcnt = num_my_rparam;
TALLOC_FREE(my_rparam);
- *rdata = (char *)memdup(my_rdata, num_my_rdata);
+ *rdata = (char *)smb_memdup(my_rdata, num_my_rdata);
if (*rdata == NULL) {
goto fail;
}
return NULL;
}
- result = memdup(dbuf.dptr, dbuf.dsize);
+ result = smb_memdup(dbuf.dptr, dbuf.dsize);
if (result == NULL) {
return NULL;
}
/* Return the raw blob. */
SAFE_FREE(*ppdata);
- *ppdata = (unsigned char *)memdup(response.data, response.length);
+ *ppdata = (unsigned char *)smb_memdup(response.data, response.length);
if ((*ppdata) == NULL && response.length > 0)
return NT_STATUS_NO_MEMORY;
*p_data_size = response.length;
TALLOC_FREE(ctx_p->token);
if (ngroups) {
- ctx_p->ut.groups = (gid_t *)memdup(groups,
- sizeof(gid_t) * ngroups);
+ ctx_p->ut.groups = (gid_t *)smb_memdup(groups,
+ sizeof(gid_t) * ngroups);
if (!ctx_p->ut.groups) {
smb_panic("memdup failed");
}
struct cache_entry *centry;
centry = SMB_XMALLOC_P(struct cache_entry);
- centry->data = (unsigned char *)memdup(data.dptr, data.dsize);
+ centry->data = (unsigned char *)smb_memdup(data.dptr, data.dsize);
if (!centry->data) {
SAFE_FREE(centry);
return NULL;
static int thread_mutex_init(smb_mutex_t *mutex, const char *name)
{
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
- mutex->mutex = memdup(&m, sizeof(m));
+ mutex->mutex = smb_memdup(&m, sizeof(m));
if (! mutex->mutex) {
errno = ENOMEM;
return -1;
static int thread_rwlock_init(smb_rwlock_t *rwlock, const char *name)
{
pthread_rwlock_t m = PTHREAD_RWLOCK_INITIALIZER;
- rwlock->rwlock = memdup(&m, sizeof(m));
+ rwlock->rwlock = smb_memdup(&m, sizeof(m));
if (! rwlock->rwlock) {
errno = ENOMEM;
return -1;