libmcrypt/lib/xmemory.c

/*
 * Copyright (C) 1998,1999 Nikos Mavroyanopoulos
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/* $Id: xmemory.c,v 1.2 2000/02/28 13:20:21 nikos Exp $ */

#ifndef LIBDEFS_H
# define LIBDEFS_H
# include <libdefs.h>
#endif
#include <bzero.h>

#ifdef HAVE_MLOCK
# ifdef HAVE_SYS_MMAN_H
#  include <sys/mman.h>
# endif
#endif

#ifdef HAVE_MLOCK
void LOCKMEM(void *x, size_t size)
{
        mlock(x, size);
}

# define UNLOCKMEM(x,y) munlock(x,y)
#else
# define LOCKMEM(x,y)
# define UNLOCKMEM(x,y)
#endif

#include <bzero.h>
#include <xmemory.h>

/* memory allocation */

void *mxmalloc(size_t size)
{
        char *x;

        x = malloc(size);

        if (x != NULL) {
                LOCKMEM(x, size);
                return x;
        } else {
                sleep(1);
                x = malloc(size);
                if (x != NULL) {
                        LOCKMEM(x, size);
                        return x;
                } else {
                        fprintf(stderr, ("Cannot allocate memory\n"));
                        return NULL;
                }
        }
}

void *mxcalloc(size_t nmemb, size_t size)
{
        char *x;

        x = calloc(nmemb, size);
        if (x != NULL) {
                LOCKMEM(x, size);
                return x;
        } else {
                sleep(1);
                x = calloc(nmemb, size);
                if (x != NULL) {
                        LOCKMEM(x, size);
                        return x;
                } else {
                        fprintf(stderr, ("Cannot allocate memory\n"));
                        return NULL;
                }
        }
}

void *mxrealloc(void *ptr, size_t size)
{
        char *x;

        x = realloc(ptr, size);
        if (x != NULL) {
                LOCKMEM(x, size);
                return x;
        } else {
                sleep(1);
                x = realloc(ptr, size);
                if (x != NULL) {
                        LOCKMEM(x, size);
                        return x;
                } else {
                        fprintf(stderr, ("Cannot allocate memory\n"));
                        return NULL;
                }
        }
}


void mxfree(void *ptr, size_t size)
{

        Bzero(ptr, size);
        UNLOCKMEM(ptr, size);
        free(ptr);

}
1	nmav	1.1	/*
2			* Copyright (C) 1998,1999 Nikos Mavroyanopoulos
3			*
4			* This library is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Library General Public
6			* License as published by the Free Software Foundation; either
7			* version 2 of the License, or (at your option) any later version.
8			*
9			* This library is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Library General Public License for more details.
13			*
14			* You should have received a copy of the GNU Library General Public
15			* License along with this library; if not, write to the
16			* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17			* Boston, MA 02111-1307, USA.
18			*/
19
20			/* $Id: xmemory.c,v 1.2 2000/02/28 13:20:21 nikos Exp $ */
21
22			#ifndef LIBDEFS_H
23			# define LIBDEFS_H
24			# include <libdefs.h>
25			#endif
26			#include <bzero.h>
27
28			#ifdef HAVE_MLOCK
29			# ifdef HAVE_SYS_MMAN_H
30			# include <sys/mman.h>
31			# endif
32			#endif
33
34			#ifdef HAVE_MLOCK
35			void LOCKMEM(void *x, size_t size)
36			{
37			mlock(x, size);
38			}
39
40			# define UNLOCKMEM(x,y) munlock(x,y)
41			#else
42			# define LOCKMEM(x,y)
43			# define UNLOCKMEM(x,y)
44			#endif
45
46			#include <bzero.h>
47			#include <xmemory.h>
48
49			/* memory allocation */
50
51			void *mxmalloc(size_t size)
52			{
53			char *x;
54
55			x = malloc(size);
56
57			if (x != NULL) {
58			LOCKMEM(x, size);
59			return x;
60			} else {
61			sleep(1);
62			x = malloc(size);
63			if (x != NULL) {
64			LOCKMEM(x, size);
65			return x;
66			} else {
67			fprintf(stderr, ("Cannot allocate memory\n"));
68			return NULL;
69			}
70			}
71			}
72
73			void *mxcalloc(size_t nmemb, size_t size)
74			{
75			char *x;
76
77			x = calloc(nmemb, size);
78			if (x != NULL) {
79			LOCKMEM(x, size);
80			return x;
81			} else {
82			sleep(1);
83			x = calloc(nmemb, size);
84			if (x != NULL) {
85			LOCKMEM(x, size);
86			return x;
87			} else {
88			fprintf(stderr, ("Cannot allocate memory\n"));
89			return NULL;
90			}
91			}
92			}
93
94			void mxrealloc(void ptr, size_t size)
95			{
96			char *x;
97
98			x = realloc(ptr, size);
99			if (x != NULL) {
100			LOCKMEM(x, size);
101			return x;
102			} else {
103			sleep(1);
104			x = realloc(ptr, size);
105			if (x != NULL) {
106			LOCKMEM(x, size);
107			return x;
108			} else {
109			fprintf(stderr, ("Cannot allocate memory\n"));
110			return NULL;
111			}
112			}
113			}
114
115
116			void mxfree(void *ptr, size_t size)
117			{
118
119			Bzero(ptr, size);
120			UNLOCKMEM(ptr, size);
121			free(ptr);
122
123			}