#include "db_config.h"
#include "db_int.h"
#ifdef DIAGNOSTIC
static void __os_guard __P((ENV *));
typedef union {
size_t size;
double align;
} db_allocinfo_t;
#endif
int
__os_umalloc(env, size, storep)
ENV *env;
size_t size;
void *storep;
{
DB_ENV *dbenv;
int ret;
dbenv = env == NULL ? NULL : env->dbenv;
if (size == 0)
++size;
if (dbenv == NULL || dbenv->db_malloc == NULL) {
if (DB_GLOBAL(j_malloc) != NULL)
*(void **)storep = DB_GLOBAL(j_malloc)(size);
else
*(void **)storep = malloc(size);
if (*(void **)storep == NULL) {
if ((ret = __os_get_errno_ret_zero()) == 0) {
ret = ENOMEM;
__os_set_errno(ENOMEM);
}
__db_err(env, ret, "malloc: %lu", (u_long)size);
return (ret);
}
return (0);
}
if ((*(void **)storep = dbenv->db_malloc(size)) == NULL) {
__db_errx(env,
"user-specified malloc function returned NULL");
return (ENOMEM);
}
return (0);
}
int
__os_urealloc(env, size, storep)
ENV *env;
size_t size;
void *storep;
{
DB_ENV *dbenv;
int ret;
void *ptr;
dbenv = env == NULL ? NULL : env->dbenv;
ptr = *(void **)storep;
if (size == 0)
++size;
if (dbenv == NULL || dbenv->db_realloc == NULL) {
if (ptr == NULL)
return (__os_umalloc(env, size, storep));
if (DB_GLOBAL(j_realloc) != NULL)
*(void **)storep = DB_GLOBAL(j_realloc)(ptr, size);
else
*(void **)storep = realloc(ptr, size);
if (*(void **)storep == NULL) {
if ((ret = __os_get_errno_ret_zero()) == 0) {
ret = ENOMEM;
__os_set_errno(ENOMEM);
}
__db_err(env, ret, "realloc: %lu", (u_long)size);
return (ret);
}
return (0);
}
if ((*(void **)storep = dbenv->db_realloc(ptr, size)) == NULL) {
__db_errx(env,
"User-specified realloc function returned NULL");
return (ENOMEM);
}
return (0);
}
void
__os_ufree(env, ptr)
ENV *env;
void *ptr;
{
DB_ENV *dbenv;
dbenv = env == NULL ? NULL : env->dbenv;
if (dbenv != NULL && dbenv->db_free != NULL)
dbenv->db_free(ptr);
else if (DB_GLOBAL(j_free) != NULL)
DB_GLOBAL(j_free)(ptr);
else
free(ptr);
}
int
__os_strdup(env, str, storep)
ENV *env;
const char *str;
void *storep;
{
size_t size;
int ret;
void *p;
*(void **)storep = NULL;
size = strlen(str) + 1;
if ((ret = __os_malloc(env, size, &p)) != 0)
return (ret);
memcpy(p, str, size);
*(void **)storep = p;
return (0);
}
int
__os_calloc(env, num, size, storep)
ENV *env;
size_t num, size;
void *storep;
{
int ret;
size *= num;
if ((ret = __os_malloc(env, size, storep)) != 0)
return (ret);
memset(*(void **)storep, 0, size);
return (0);
}
int
__os_malloc(env, size, storep)
ENV *env;
size_t size;
void *storep;
{
int ret;
void *p;
*(void **)storep = NULL;
if (size == 0)
++size;
#ifdef DIAGNOSTIC
size += sizeof(db_allocinfo_t) + 1;
#endif
if (DB_GLOBAL(j_malloc) != NULL)
p = DB_GLOBAL(j_malloc)(size);
else
p = malloc(size);
if (p == NULL) {
if ((ret = __os_get_errno_ret_zero()) == 0) {
ret = ENOMEM;
__os_set_errno(ENOMEM);
}
__db_err(env, ret, "malloc: %lu", (u_long)size);
return (ret);
}
#ifdef DIAGNOSTIC
memset(p, CLEAR_BYTE, size);
((u_int8_t *)p)[size - 1] = CLEAR_BYTE;
((db_allocinfo_t *)p)->size = size;
p = &((db_allocinfo_t *)p)[1];
#endif
*(void **)storep = p;
return (0);
}
int
__os_realloc(env, size, storep)
ENV *env;
size_t size;
void *storep;
{
int ret;
void *p, *ptr;
ptr = *(void **)storep;
if (size == 0)
++size;
if (ptr == NULL)
return (__os_malloc(env, size, storep));
#ifdef DIAGNOSTIC
size += sizeof(db_allocinfo_t) + 1;
ptr = &((db_allocinfo_t *)ptr)[-1];
{
size_t s;
s = ((db_allocinfo_t *)ptr)->size;
if (((u_int8_t *)ptr)[s - 1] != CLEAR_BYTE)
__os_guard(env);
}
#endif
if (DB_GLOBAL(j_realloc) != NULL)
p = DB_GLOBAL(j_realloc)(ptr, size);
else
p = realloc(ptr, size);
if (p == NULL) {
if ((ret = __os_get_errno_ret_zero()) == 0) {
ret = ENOMEM;
__os_set_errno(ENOMEM);
}
__db_err(env, ret, "realloc: %lu", (u_long)size);
return (ret);
}
#ifdef DIAGNOSTIC
((u_int8_t *)p)[size - 1] = CLEAR_BYTE;
((db_allocinfo_t *)p)->size = size;
p = &((db_allocinfo_t *)p)[1];
#endif
*(void **)storep = p;
return (0);
}
void
__os_free(env, ptr)
ENV *env;
void *ptr;
{
#ifdef DIAGNOSTIC
size_t size;
#endif
if (ptr == NULL)
return;
#ifdef DIAGNOSTIC
ptr = &((db_allocinfo_t *)ptr)[-1];
size = ((db_allocinfo_t *)ptr)->size;
if (((u_int8_t *)ptr)[size - 1] != CLEAR_BYTE)
__os_guard(env);
if (size != 0)
memset(ptr, CLEAR_BYTE, size);
#else
COMPQUIET(env, NULL);
#endif
if (DB_GLOBAL(j_free) != NULL)
DB_GLOBAL(j_free)(ptr);
else
free(ptr);
}
#ifdef DIAGNOSTIC
static void
__os_guard(env)
ENV *env;
{
__db_errx(env, "Guard byte incorrect during free");
__os_abort(env);
}
#endif
void *
__ua_memcpy(dst, src, len)
void *dst;
const void *src;
size_t len;
{
return ((void *)memcpy(dst, src, len));
}