/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
- Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Frank Ch. Eigler <fche@redhat.com>
and Graydon Hoare <graydon@redhat.com>
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#if !defined(__FreeBSD__) && !defined(__APPLE__)
#define _POSIX_SOURCE
#endif /* Some BSDs break <sys/socket.h> if this is defined. */
-#define _GNU_SOURCE
+#define _GNU_SOURCE
#define _XOPEN_SOURCE
#define _BSD_TYPES
#define __EXTENSIONS__
#define _ALL_SOURCE
#define _LARGE_FILE_API
+#define _LARGEFILE64_SOURCE
#define _XOPEN_SOURCE_EXTENDED 1
#include <string.h>
-#include <strings.h>
+#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
+#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <time.h>
+#include <ctype.h>
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+#ifdef HAVE_DIRENT_H
+#include <dirent.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#ifdef HAVE_SYS_IPC_H
+#include <sys/ipc.h>
+#endif
+#ifdef HAVE_SYS_SEM_H
+#include <sys/sem.h>
+#endif
+#ifdef HAVE_SYS_SHM_H
+#include <sys/shm.h>
+#endif
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+#ifdef HAVE_GRP_H
+#include <grp.h>
+#endif
+#ifdef HAVE_MNTENT_H
+#include <mntent.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
#include "mf-runtime.h"
#include "mf-impl.h"
/* A bunch of independent stdlib/unistd hook functions, all
intercepted by mf-runtime.h macros. */
-#ifdef __FreeBSD__
-#undef WRAP_memrchr
-#undef WRAP_memmem
-#include <dlfcn.h>
+#ifndef HAVE_STRNLEN
static inline size_t (strnlen) (const char* str, size_t n)
{
const char *s;
}
#endif
+
/* str*,mem*,b* */
-#ifdef WRAP_memcpy
WRAPPER2(void *, memcpy, void *dest, const void *src, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memcpy dest");
return memcpy (dest, src, n);
}
-#endif
-#ifdef WRAP_memmove
WRAPPER2(void *, memmove, void *dest, const void *src, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memmove dest");
return memmove (dest, src, n);
}
-#endif
-#ifdef WRAP_memset
+
WRAPPER2(void *, memset, void *s, int c, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "memset dest");
return memset (s, c, n);
}
-#endif
-#ifdef WRAP_memcmp
+
WRAPPER2(int, memcmp, const void *s1, const void *s2, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "memcmp 2nd arg");
return memcmp (s1, s2, n);
}
-#endif
-#ifdef WRAP_memchr
+
WRAPPER2(void *, memchr, const void *s, int c, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memchr region");
return memchr (s, c, n);
}
-#endif
-#ifdef WRAP_memrchr
+
+#ifdef HAVE_MEMRCHR
WRAPPER2(void *, memrchr, const void *s, int c, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
}
#endif
-#ifdef WRAP_strcpy
+
WRAPPER2(char *, strcpy, char *dest, const char *src)
{
/* nb: just because strlen(src) == n doesn't mean (src + n) or (src + n +
size_t n = strlen (src);
TRACE ("%s\n", __PRETTY_FUNCTION__);
- MF_VALIDATE_EXTENT(src, CLAMPADD(n, 1), __MF_CHECK_READ, "strcpy src");
+ MF_VALIDATE_EXTENT(src, CLAMPADD(n, 1), __MF_CHECK_READ, "strcpy src");
MF_VALIDATE_EXTENT(dest, CLAMPADD(n, 1), __MF_CHECK_WRITE, "strcpy dest");
return strcpy (dest, src);
}
-#endif
-#ifdef WRAP_strncpy
+
+#ifdef HAVE_STRNCPY
WRAPPER2(char *, strncpy, char *dest, const char *src, size_t n)
{
size_t len = strnlen (src, n);
}
#endif
-#ifdef WRAP_strcat
+
WRAPPER2(char *, strcat, char *dest, const char *src)
{
size_t dest_sz;
size_t src_sz;
TRACE ("%s\n", __PRETTY_FUNCTION__);
dest_sz = strlen (dest);
- src_sz = strlen (src);
+ src_sz = strlen (src);
MF_VALIDATE_EXTENT(src, CLAMPADD(src_sz, 1), __MF_CHECK_READ, "strcat src");
MF_VALIDATE_EXTENT(dest, CLAMPADD(dest_sz, CLAMPADD(src_sz, 1)),
__MF_CHECK_WRITE, "strcat dest");
return strcat (dest, src);
}
-#endif
-#ifdef WRAP_strncat
+
WRAPPER2(char *, strncat, char *dest, const char *src, size_t n)
{
/* nb: validating the extents (s,n) might be a mistake for two reasons.
-
- (1) the string s might be shorter than n chars, and n is just a
+
+ (1) the string s might be shorter than n chars, and n is just a
poor choice by the programmer. this is not a "true" error in the
sense that the call to strncat would still be ok.
-
+
(2) we could try to compensate for case (1) by calling strlen(s) and
using that as a bound for the extent to verify, but strlen might fall off
the end of a non-terminated string, leading to a false positive.
-
+
so we will call strnlen(s,n) and use that as a bound.
if strnlen returns a length beyond the end of the registered extent
__MF_CHECK_WRITE, "strncat dest");
return strncat (dest, src, n);
}
-#endif
-#ifdef WRAP_strcmp
+
WRAPPER2(int, strcmp, const char *s1, const char *s2)
{
size_t s1_sz;
size_t s2_sz;
TRACE ("%s\n", __PRETTY_FUNCTION__);
s1_sz = strlen (s1);
- s2_sz = strlen (s2);
+ s2_sz = strlen (s2);
MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcmp 1st arg");
MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_WRITE, "strcmp 2nd arg");
return strcmp (s1, s2);
}
-#endif
-#ifdef WRAP_strcasecmp
+
WRAPPER2(int, strcasecmp, const char *s1, const char *s2)
{
size_t s1_sz;
size_t s2_sz;
TRACE ("%s\n", __PRETTY_FUNCTION__);
s1_sz = strlen (s1);
- s2_sz = strlen (s2);
+ s2_sz = strlen (s2);
MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcasecmp 1st arg");
MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_READ, "strcasecmp 2nd arg");
return strcasecmp (s1, s2);
}
-#endif
-#ifdef WRAP_strncmp
+
WRAPPER2(int, strncmp, const char *s1, const char *s2, size_t n)
{
size_t s1_sz;
MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncmp 2nd arg");
return strncmp (s1, s2, n);
}
-#endif
-#ifdef WRAP_strncasecmp
+
WRAPPER2(int, strncasecmp, const char *s1, const char *s2, size_t n)
{
size_t s1_sz;
MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncasecmp 2nd arg");
return strncasecmp (s1, s2, n);
}
-#endif
-#ifdef WRAP_strdup
+
WRAPPER2(char *, strdup, const char *s)
{
DECLARE(void *, malloc, size_t sz);
size_t n = strlen (s);
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strdup region");
- result = (char *)CALL_REAL(malloc,
+ result = (char *)CALL_REAL(malloc,
CLAMPADD(CLAMPADD(n,1),
CLAMPADD(__mf_opts.crumple_zone,
__mf_opts.crumple_zone)));
__mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strdup region");
return result;
}
-#endif
-#ifdef WRAP_strndup
+
WRAPPER2(char *, strndup, const char *s, size_t n)
{
DECLARE(void *, malloc, size_t sz);
MF_VALIDATE_EXTENT(s, sz, __MF_CHECK_READ, "strndup region"); /* nb: strNdup */
/* note: strndup still adds a \0, even with the N limit! */
- result = (char *)CALL_REAL(malloc,
+ result = (char *)CALL_REAL(malloc,
CLAMPADD(CLAMPADD(n,1),
CLAMPADD(__mf_opts.crumple_zone,
__mf_opts.crumple_zone)));
-
+
if (UNLIKELY(! result)) return result;
result += __mf_opts.crumple_zone;
__mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strndup region");
return result;
}
-#endif
-#ifdef WRAP_strchr
+
WRAPPER2(char *, strchr, const char *s, int c)
{
size_t n;
MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strchr region");
return strchr (s, c);
}
-#endif
-#ifdef WRAP_strrchr
+
WRAPPER2(char *, strrchr, const char *s, int c)
{
size_t n;
MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strrchr region");
return strrchr (s, c);
}
-#endif
-#ifdef WRAP_strstr
+
WRAPPER2(char *, strstr, const char *haystack, const char *needle)
{
size_t haystack_sz;
MF_VALIDATE_EXTENT(needle, CLAMPADD(needle_sz, 1), __MF_CHECK_READ, "strstr needle");
return strstr (haystack, needle);
}
-#endif
-#ifdef WRAP_memmem
-WRAPPER2(void *, memmem,
+
+#ifdef HAVE_MEMMEM
+WRAPPER2(void *, memmem,
const void *haystack, size_t haystacklen,
const void *needle, size_t needlelen)
{
}
#endif
-#ifdef WRAP_strlen
+
WRAPPER2(size_t, strlen, const char *s)
{
size_t result = strlen (s);
MF_VALIDATE_EXTENT(s, CLAMPADD(result, 1), __MF_CHECK_READ, "strlen region");
return result;
}
-#endif
-#ifdef WRAP_strnlen
+
WRAPPER2(size_t, strnlen, const char *s, size_t n)
{
size_t result = strnlen (s, n);
MF_VALIDATE_EXTENT(s, result, __MF_CHECK_READ, "strnlen region");
return result;
}
-#endif
-#ifdef WRAP_bzero
+
WRAPPER2(void, bzero, void *s, size_t n)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "bzero region");
bzero (s, n);
}
-#endif
-#ifdef WRAP_bcopy
+
#undef bcopy
WRAPPER2(void, bcopy, const void *src, void *dest, size_t n)
{
MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "bcopy dest");
bcopy (src, dest, n);
}
-#endif
-#ifdef WRAP_bcmp
+
#undef bcmp
WRAPPER2(int, bcmp, const void *s1, const void *s2, size_t n)
{
MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "bcmp 2nd arg");
return bcmp (s1, s2, n);
}
-#endif
-#ifdef WRAP_index
+
WRAPPER2(char *, index, const char *s, int c)
{
size_t n = strlen (s);
MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "index region");
return index (s, c);
}
-#endif
-#ifdef WRAP_rindex
+
WRAPPER2(char *, rindex, const char *s, int c)
{
size_t n = strlen (s);
MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "rindex region");
return rindex (s, c);
}
-#endif
/* XXX: stpcpy, memccpy */
-
/* XXX: *printf,*scanf */
-
/* XXX: setjmp, longjmp */
-#ifdef WRAP_asctime
WRAPPER2(char *, asctime, struct tm *tm)
{
static char *reg_result = NULL;
}
return result;
}
-#endif
-#ifdef WRAP_ctime
+
WRAPPER2(char *, ctime, const time_t *timep)
{
static char *reg_result = NULL;
}
return result;
}
-#endif
-#ifdef WRAP_localtime
WRAPPER2(struct tm*, localtime, const time_t *timep)
{
static struct tm *reg_result = NULL;
}
return result;
}
-#endif
-#ifdef WRAP_gmtime
+
WRAPPER2(struct tm*, gmtime, const time_t *timep)
{
static struct tm *reg_result = NULL;
}
return result;
}
-#endif
-
/* EL start */
/* The following indicate if the result of the corresponding function
* should be explicitly un/registered by the wrapper
*/
-#define MF_REGISTER_strerror __MF_TYPE_STATIC
+
+#ifdef __FreeBSD__
+#define MF_REGISTER_fopen __MF_TYPE_STATIC
+#else
#undef MF_REGISTER_fopen
+#endif
#define MF_RESULT_SIZE_fopen (sizeof (FILE))
+
#undef MF_REGISTER_opendir
#define MF_RESULT_SIZE_opendir 0 /* (sizeof (DIR)) */
#undef MF_REGISTER_readdir
#define MF_REGISTER_shmat __MF_TYPE_GUESS
-#ifdef WRAP_time
#include <time.h>
WRAPPER2(time_t, time, time_t *timep)
{
"time timep");
return time (timep);
}
-#endif
-#ifdef WRAP_strerror
+
WRAPPER2(char *, strerror, int errnum)
{
char *p;
- size_t n;
+ static char * last_strerror = NULL;
+
TRACE ("%s\n", __PRETTY_FUNCTION__);
p = strerror (errnum);
- if (NULL != p) {
- n = strlen (p);
- n = CLAMPADD(n, 1);
-#ifdef MF_REGISTER_strerror
- __mf_register (p, n, MF_REGISTER_strerror, "strerror result");
-#endif
- MF_VALIDATE_EXTENT (p, n, __MF_CHECK_WRITE, "strerror result");
- }
+ if (last_strerror != NULL)
+ __mf_unregister (last_strerror, 0, __MF_TYPE_STATIC);
+ if (NULL != p)
+ __mf_register (p, strlen (p) + 1, __MF_TYPE_STATIC, "strerror result");
+ last_strerror = p;
return p;
}
-#endif
-#ifdef WRAP_fopen
+
+
+/* An auxiliary data structure for tracking the hand-made stdio
+ buffers we generate during the fopen/fopen64 hooks. In a civilized
+ language, this would be a simple dynamically sized FILE*->char*
+ lookup table, but this is C and we get to do it by hand. */
+struct mf_filebuffer
+{
+ FILE *file;
+ char *buffer;
+ struct mf_filebuffer *next;
+};
+static struct mf_filebuffer *mf_filebuffers = NULL;
+
+static void
+mkbuffer (FILE *f)
+{
+ /* Reset any buffer automatically provided by libc, since this may
+ have been done via mechanisms that libmudflap couldn't
+ intercept. */
+ int rc;
+ size_t bufsize = BUFSIZ;
+ int bufmode;
+ char *buffer = malloc (bufsize);
+ struct mf_filebuffer *b = malloc (sizeof (struct mf_filebuffer));
+ assert ((buffer != NULL) && (b != NULL));
+
+ /* Link it into list. */
+ b->file = f;
+ b->buffer = buffer;
+ b->next = mf_filebuffers;
+ mf_filebuffers = b;
+
+ /* Determine how the file is supposed to be buffered at the moment. */
+ bufmode = fileno (f) == 2 ? _IONBF : (isatty (fileno (f)) ? _IOLBF : _IOFBF);
+
+ rc = setvbuf (f, buffer, bufmode, bufsize);
+ assert (rc == 0);
+}
+
+static void
+unmkbuffer (FILE *f)
+{
+ struct mf_filebuffer *b = mf_filebuffers;
+ struct mf_filebuffer **pb = & mf_filebuffers;
+ while (b != NULL)
+ {
+ if (b->file == f)
+ {
+ *pb = b->next;
+ free (b->buffer);
+ free (b);
+ return;
+ }
+ pb = & b->next;
+ b = b->next;
+ }
+}
+
+
+
WRAPPER2(FILE *, fopen, const char *path, const char *mode)
{
size_t n;
__mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen result");
#endif
MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen result");
+
+ mkbuffer (p);
+ }
+
+ return p;
+}
+
+
+WRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode, size_t size)
+{
+ int rc = 0;
+ TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+ MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, "setvbuf stream");
+
+ unmkbuffer (stream);
+
+ if (buf != NULL)
+ MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_WRITE, "setvbuf buffer");
+
+ /* Override the user only if it's an auto-allocated buffer request. Otherwise
+ assume that the supplied buffer is already known to libmudflap. */
+ if ((buf == NULL) && ((mode == _IOFBF) || (mode == _IOLBF)))
+ mkbuffer (stream);
+ else
+ rc = setvbuf (stream, buf, mode, size);
+
+ return rc;
+}
+
+
+#ifdef HAVE_SETBUF
+WRAPPER2(int, setbuf, FILE* stream, char *buf)
+{
+ return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
+}
+#endif
+
+#ifdef HAVE_SETBUFFER
+WRAPPER2(int, setbuffer, FILE* stream, char *buf, size_t sz)
+{
+ return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, sz);
+}
+#endif
+
+#ifdef HAVE_SETLINEBUF
+WRAPPER2(int, setlinebuf, FILE* stream)
+{
+ return __mfwrap_setvbuf(stream, NULL, _IOLBF, 0);
+}
+#endif
+
+
+
+WRAPPER2(FILE *, fdopen, int fd, const char *mode)
+{
+ size_t n;
+ FILE *p;
+ TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+ n = strlen (mode);
+ MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fdopen mode");
+
+ p = fdopen (fd, mode);
+ if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+ __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fdopen result");
+#endif
+ MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fdopen result");
+
+ mkbuffer (p);
}
return p;
}
+
+
+WRAPPER2(FILE *, freopen, const char *path, const char *mode, FILE *s)
+{
+ size_t n;
+ FILE *p;
+ TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+ n = strlen (path);
+ MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen path");
+
+ MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen stream");
+ unmkbuffer (s);
+
+ n = strlen (mode);
+ MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen mode");
+
+ p = freopen (path, mode, s);
+ if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+ __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen result");
#endif
+ MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen result");
+
+ mkbuffer (p);
+ }
+
+ return p;
+}
+
#ifdef HAVE_FOPEN64
-#ifdef WRAP_fopen64
WRAPPER2(FILE *, fopen64, const char *path, const char *mode)
{
size_t n;
__mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen64 result");
#endif
MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen64 result");
+
+ mkbuffer (p);
}
return p;
}
#endif
+
+
+#ifdef HAVE_FREOPEN64
+WRAPPER2(FILE *, freopen64, const char *path, const char *mode, FILE *s)
+{
+ size_t n;
+ FILE *p;
+ TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+ n = strlen (path);
+ MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 path");
+
+ MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen64 stream");
+ unmkbuffer (s);
+
+ n = strlen (mode);
+ MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 mode");
+
+ p = freopen (path, mode, s);
+ if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+ __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen64 result");
+#endif
+ MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen64 result");
+
+ mkbuffer (p);
+ }
+
+ return p;
+}
#endif
-#ifdef WRAP_fclose
+
WRAPPER2(int, fclose, FILE *stream)
{
int resp;
"fclose stream");
resp = fclose (stream);
#ifdef MF_REGISTER_fopen
- __mf_unregister (stream, sizeof (*stream));
+ __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
#endif
+ unmkbuffer (stream);
return resp;
}
-#endif
-#ifdef WRAP_fread
+
WRAPPER2(size_t, fread, void *ptr, size_t size, size_t nmemb, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_WRITE, "fread buffer");
return fread (ptr, size, nmemb, stream);
}
-#endif
-#ifdef WRAP_fwrite
+
WRAPPER2(size_t, fwrite, const void *ptr, size_t size, size_t nmemb,
FILE *stream)
{
MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_READ, "fwrite buffer");
return fwrite (ptr, size, nmemb, stream);
}
-#endif
-#ifdef WRAP_fgetc
+
WRAPPER2(int, fgetc, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"fgetc stream");
return fgetc (stream);
}
-#endif
-#ifdef WRAP_fgets
+
WRAPPER2(char *, fgets, char *s, int size, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (s, size, __MF_CHECK_WRITE, "fgets buffer");
return fgets (s, size, stream);
}
-#endif
-#ifdef WRAP_getc
+
WRAPPER2(int, getc, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"getc stream");
return getc (stream);
}
-#endif
-#ifdef WRAP_gets
+
WRAPPER2(char *, gets, char *s)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
}
return s;
}
-#endif
-#ifdef WRAP_ungetc
+
WRAPPER2(int, ungetc, int c, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"ungetc stream");
return ungetc (c, stream);
}
-#endif
-#ifdef WRAP_fputc
+
WRAPPER2(int, fputc, int c, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"fputc stream");
return fputc (c, stream);
}
-#endif
-#ifdef WRAP_fputs
+
WRAPPER2(int, fputs, const char *s, FILE *stream)
{
size_t n;
"fputs stream");
return fputs (s, stream);
}
-#endif
-#ifdef WRAP_putc
+
WRAPPER2(int, putc, int c, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"putc stream");
return putc (c, stream);
}
-#endif
-#ifdef WRAP_puts
+
WRAPPER2(int, puts, const char *s)
{
size_t n;
MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "puts buffer");
return puts (s);
}
-#endif
-#ifdef WRAP_clearerr
+
WRAPPER2(void, clearerr, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"clearerr stream");
clearerr (stream);
}
-#endif
-#ifdef WRAP_feof
+
WRAPPER2(int, feof, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"feof stream");
return feof (stream);
}
-#endif
-#ifdef WRAP_ferror
+
WRAPPER2(int, ferror, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"ferror stream");
return ferror (stream);
}
-#endif
-#ifdef WRAP_fileno
-#include <stdio.h>
+
WRAPPER2(int, fileno, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"fileno stream");
return fileno (stream);
}
-#endif
-#ifdef WRAP_printf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, printf, const char *format, ...)
{
size_t n;
va_end (ap);
return result;
}
-#endif
-#ifdef WRAP_fprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, fprintf, FILE *stream, const char *format, ...)
{
size_t n;
va_end (ap);
return result;
}
-#endif
-#ifdef WRAP_sprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, sprintf, char *str, const char *format, ...)
{
size_t n;
MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "sprintf str");
return result;
}
-#endif
-#ifdef WRAP_snprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, snprintf, char *str, size_t size, const char *format, ...)
{
size_t n;
va_end (ap);
return result;
}
-#endif
-#ifdef WRAP_vprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, vprintf, const char *format, va_list ap)
{
size_t n;
"vprintf format");
return vprintf (format, ap);
}
-#endif
-#ifdef WRAP_vfprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, vfprintf, FILE *stream, const char *format, va_list ap)
{
size_t n;
"vfprintf format");
return vfprintf (stream, format, ap);
}
-#endif
-#ifdef WRAP_vsprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, vsprintf, char *str, const char *format, va_list ap)
{
size_t n;
MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "vsprintf str");
return result;
}
-#endif
-#ifdef WRAP_vsnprintf
-#include <stdio.h>
-#include <stdarg.h>
+
WRAPPER2(int, vsnprintf, char *str, size_t size, const char *format,
va_list ap)
{
"vsnprintf format");
return vsnprintf (str, size, format, ap);
}
-#endif
-#ifdef WRAP_access
+
WRAPPER2(int , access, const char *path, int mode)
{
size_t n;
MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "access path");
return access (path, mode);
}
-#endif
-#ifdef WRAP_remove
+
WRAPPER2(int , remove, const char *path)
{
size_t n;
MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "remove path");
return remove (path);
}
-#endif
-#ifdef WRAP_fflush
+
WRAPPER2(int, fflush, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
- MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
- "fflush stream");
+ if (stream != NULL)
+ MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+ "fflush stream");
return fflush (stream);
}
-#endif
-#ifdef WRAP_fseek
+
WRAPPER2(int, fseek, FILE *stream, long offset, int whence)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"fseek stream");
return fseek (stream, offset, whence);
}
-#endif
+
#ifdef HAVE_FSEEKO64
-#ifdef WRAP_fseeko64
WRAPPER2(int, fseeko64, FILE *stream, off64_t offset, int whence)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
return fseeko64 (stream, offset, whence);
}
#endif
-#endif
-#ifdef WRAP_ftell
+
WRAPPER2(long, ftell, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"ftell stream");
return ftell (stream);
}
-#endif
+
#ifdef HAVE_FTELLO64
-#ifdef WRAP_ftello64
WRAPPER2(off64_t, ftello64, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
return ftello64 (stream);
}
#endif
-#endif
-#ifdef WRAP_rewind
+
WRAPPER2(void, rewind, FILE *stream)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"rewind stream");
rewind (stream);
}
-#endif
-#ifdef WRAP_fgetpos
+
WRAPPER2(int, fgetpos, FILE *stream, fpos_t *pos)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_WRITE, "fgetpos pos");
return fgetpos (stream, pos);
}
-#endif
-#ifdef WRAP_fsetpos
+
WRAPPER2(int, fsetpos, FILE *stream, fpos_t *pos)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_READ, "fsetpos pos");
return fsetpos (stream, pos);
}
-#endif
-#ifdef WRAP_stat
-#include <sys/stat.h>
+
WRAPPER2(int , stat, const char *path, struct stat *buf)
{
size_t n;
MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat buf");
return stat (path, buf);
}
-#endif
+
#ifdef HAVE_STAT64
-#ifdef WRAP_stat64
-#include <sys/stat.h>
WRAPPER2(int , stat64, const char *path, struct stat64 *buf)
{
size_t n;
return stat64 (path, buf);
}
#endif
-#endif
-#ifdef WRAP_fstat
-#include <sys/stat.h>
+
WRAPPER2(int , fstat, int filedes, struct stat *buf)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "fstat buf");
return fstat (filedes, buf);
}
-#endif
-#ifdef WRAP_lstat
-#include <sys/stat.h>
+
WRAPPER2(int , lstat, const char *path, struct stat *buf)
{
size_t n;
MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "lstat buf");
return lstat (path, buf);
}
-#endif
-#ifdef WRAP_mkfifo
-#include <sys/stat.h>
+
WRAPPER2(int , mkfifo, const char *path, mode_t mode)
{
size_t n;
MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "mkfifo path");
return mkfifo (path, mode);
}
-#endif
-
-#ifdef WRAP_setvbuf
-WRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode , size_t size)
-{
- TRACE ("%s\n", __PRETTY_FUNCTION__);
- MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
- "setvbuf stream");
- if (NULL != buf)
- MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_READ, "setvbuf buf");
- return setvbuf (stream, buf, mode, size);
-}
-#endif
-#ifdef WRAP_setbuf
-WRAPPER2(void, setbuf, FILE *stream, char *buf)
-{
- TRACE ("%s\n", __PRETTY_FUNCTION__);
- MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
- "setbuf stream");
- if (NULL != buf)
- MF_VALIDATE_EXTENT (buf, BUFSIZ, __MF_CHECK_READ, "setbuf buf");
- setbuf (stream, buf);
-}
-#endif
-#ifdef WRAP_opendir
-#include <dirent.h>
+#ifdef HAVE_DIRENT_H
WRAPPER2(DIR *, opendir, const char *path)
{
DIR *p;
}
return p;
}
-#endif
-#ifdef WRAP_closedir
-#include <dirent.h>
+
WRAPPER2(int, closedir, DIR *dir)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_WRITE, "closedir dir");
#ifdef MF_REGISTER_opendir
- __mf_unregister (dir, MF_RESULT_SIZE_opendir);
+ __mf_unregister (dir, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir);
#endif
return closedir (dir);
}
-#endif
-#ifdef WRAP_readdir
-#include <dirent.h>
+
WRAPPER2(struct dirent *, readdir, DIR *dir)
{
struct dirent *p;
}
#endif
-#ifdef WRAP_recv
-#include <sys/socket.h>
+
+#ifdef HAVE_SYS_SOCKET_H
+
WRAPPER2(int, recv, int s, void *buf, size_t len, int flags)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recv buf");
return recv (s, buf, len, flags);
}
-#endif
-#ifdef WRAP_recvfrom
-#include <sys/socket.h>
+
WRAPPER2(int, recvfrom, int s, void *buf, size_t len, int flags,
struct sockaddr *from, socklen_t *fromlen)
{
"recvfrom from");
return recvfrom (s, buf, len, flags, from, fromlen);
}
-#endif
-#ifdef WRAP_recvmsg
-#include <sys/socket.h>
+
WRAPPER2(int, recvmsg, int s, struct msghdr *msg, int flags)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_WRITE, "recvmsg msg");
return recvmsg (s, msg, flags);
}
-#endif
-#ifdef WRAP_send
-#include <sys/socket.h>
+
WRAPPER2(int, send, int s, const void *msg, size_t len, int flags)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "send msg");
return send (s, msg, len, flags);
}
-#endif
-#ifdef WRAP_sendto
-#include <sys/socket.h>
+
WRAPPER2(int, sendto, int s, const void *msg, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen)
{
MF_VALIDATE_EXTENT (to, (size_t)tolen, __MF_CHECK_WRITE, "sendto to");
return sendto (s, msg, len, flags, to, tolen);
}
-#endif
-#ifdef WRAP_sendmsg
-#include <sys/socket.h>
+
WRAPPER2(int, sendmsg, int s, const void *msg, int flags)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_READ, "sendmsg msg");
return sendmsg (s, msg, flags);
}
-#endif
-#ifdef WRAP_setsockopt
-#include <sys/socket.h>
+
WRAPPER2(int, setsockopt, int s, int level, int optname, const void *optval,
socklen_t optlen)
{
"setsockopt optval");
return setsockopt (s, level, optname, optval, optlen);
}
-#endif
-#ifdef WRAP_getsockopt
-#include <sys/socket.h>
+
WRAPPER2(int, getsockopt, int s, int level, int optname, void *optval,
socklen_t *optlen)
{
"getsockopt optval");
return getsockopt (s, level, optname, optval, optlen);
}
-#endif
-#ifdef WRAP_accept
-#include <sys/socket.h>
+
WRAPPER2(int, accept, int s, struct sockaddr *addr, socklen_t *addrlen)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
- MF_VALIDATE_EXTENT (addr, (size_t)*addrlen, __MF_CHECK_WRITE, "accept addr");
+ if (addr != NULL)
+ MF_VALIDATE_EXTENT (addr, (size_t)*addrlen, __MF_CHECK_WRITE, "accept addr");
return accept (s, addr, addrlen);
}
-#endif
-#ifdef WRAP_bind
-#include <sys/socket.h>
+
WRAPPER2(int, bind, int sockfd, struct sockaddr *addr, socklen_t addrlen)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_WRITE, "bind addr");
return bind (sockfd, addr, addrlen);
}
-#endif
-#ifdef WRAP_connect
-#include <sys/socket.h>
+
WRAPPER2(int, connect, int sockfd, const struct sockaddr *addr,
socklen_t addrlen)
{
"connect addr");
return connect (sockfd, addr, addrlen);
}
-#endif
-#ifdef WRAP_gethostname
+#endif /* HAVE_SYS_SOCKET_H */
+
+
WRAPPER2(int, gethostname, char *name, size_t len)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
MF_VALIDATE_EXTENT (name, len, __MF_CHECK_WRITE, "gethostname name");
return gethostname (name, len);
}
-#endif
-#ifdef WRAP_sethostname
+
+#ifdef HAVE_SETHOSTNAME
WRAPPER2(int, sethostname, const char *name, size_t len)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
}
#endif
-#ifdef WRAP_gethostbyname
-#include <netdb.h>
+
+#ifdef HAVE_NETDB_H
+
WRAPPER2(struct hostent *, gethostbyname, const char *name)
{
struct hostent *p;
}
return p;
}
-#endif
-#ifdef WRAP_wait
-#include <sys/wait.h>
+#endif /* HAVE_NETDB_H */
+
+
+#ifdef HAVE_SYS_WAIT_H
+
WRAPPER2(pid_t, wait, int *status)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"wait status");
return wait (status);
}
-#endif
-#ifdef WRAP_waitpid
-#include <sys/wait.h>
+
WRAPPER2(pid_t, waitpid, pid_t pid, int *status, int options)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"waitpid status");
return waitpid (pid, status, options);
}
-#endif
-#ifdef WRAP_popen
+#endif /* HAVE_SYS_WAIT_H */
+
+
WRAPPER2(FILE *, popen, const char *command, const char *mode)
{
size_t n;
}
return p;
}
-#endif
-#ifdef WRAP_pclose
+
WRAPPER2(int, pclose, FILE *stream)
{
int resp;
"pclose stream");
resp = pclose (stream);
#ifdef MF_REGISTER_fopen
- __mf_unregister (stream, sizeof (*stream));
+ __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
#endif
return resp;
}
-#endif
-#ifdef WRAP_execve
+
WRAPPER2(int, execve, const char *path, char *const argv [],
char *const envp[])
{
}
return execve (path, argv, envp);
}
-#endif
-#ifdef WRAP_execv
+
WRAPPER2(int, execv, const char *path, char *const argv [])
{
size_t n;
}
return execv (path, argv);
}
-#endif
-#ifdef WRAP_execvp
+
WRAPPER2(int, execvp, const char *path, char *const argv [])
{
size_t n;
}
return execvp (path, argv);
}
-#endif
-#ifdef WRAP_system
+
WRAPPER2(int, system, const char *string)
{
size_t n;
"system string");
return system (string);
}
-#endif
-#ifdef WRAP_dlopen
+
WRAPPER2(void *, dlopen, const char *path, int flags)
{
void *p;
}
return p;
}
-#endif
-#ifdef WRAP_dlclose
+
WRAPPER2(int, dlclose, void *handle)
{
int resp;
MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlclose handle");
resp = dlclose (handle);
#ifdef MF_REGISTER_dlopen
- __mf_unregister (handle, 0);
+ __mf_unregister (handle, 0, MF_REGISTER_dlopen);
#endif
return resp;
}
-#endif
-#ifdef WRAP_dlerror
+
WRAPPER2(char *, dlerror)
{
char *p;
}
return p;
}
-#endif
-#ifdef WRAP_dlsym
+
WRAPPER2(void *, dlsym, void *handle, char *symbol)
{
size_t n;
}
return p;
}
-#endif
-#ifdef WRAP_semop
-#include <sys/ipc.h>
-#include <sys/sem.h>
+
+#if defined (HAVE_SYS_IPC_H) && defined (HAVE_SYS_SEM_H) && defined (HAVE_SYS_SHM_H)
+
WRAPPER2(int, semop, int semid, struct sembuf *sops, unsigned nsops)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
"semop sops");
return semop (semid, sops, nsops);
}
-#endif
-#ifdef WRAP_semctl
-#include <sys/ipc.h>
-#include <sys/sem.h>
+
#ifndef HAVE_UNION_SEMUN
union semun {
int val; /* value for SETVAL */
"semctl array");
break;
#ifdef IPC_INFO
- /* FreeBSD 5.1 headers include IPC_INFO but not the __buf field. */
-#if !defined(__FreeBSD__)
+ /* FreeBSD 5.1 And Cygwin headers include IPC_INFO but not the __buf field. */
+#if !defined(__FreeBSD__) && !defined(__CYGWIN__)
case IPC_INFO:
MF_VALIDATE_EXTENT (arg.__buf, sizeof (*arg.__buf), __MF_CHECK_WRITE,
"semctl __buf");
}
return semctl (semid, semnum, cmd, arg);
}
-#endif
-#ifdef WRAP_shmctl
-#include <sys/ipc.h>
-#include <sys/shm.h>
+
WRAPPER2(int, shmctl, int shmid, int cmd, struct shmid_ds *buf)
{
TRACE ("%s\n", __PRETTY_FUNCTION__);
}
return shmctl (shmid, cmd, buf);
}
-#endif
-#ifdef WRAP_shmat
-#include <sys/ipc.h>
-#include <sys/shm.h>
+
WRAPPER2(void *, shmat, int shmid, const void *shmaddr, int shmflg)
{
void *p;
#endif
return p;
}
-#endif
-#ifdef WRAP_shmdt
-#include <sys/ipc.h>
-#include <sys/shm.h>
+
WRAPPER2(int, shmdt, const void *shmaddr)
{
int resp;
TRACE ("%s\n", __PRETTY_FUNCTION__);
resp = shmdt (shmaddr);
#ifdef MF_REGISTER_shmat
- __mf_unregister ((void *)shmaddr, 0);
+ __mf_unregister ((void *)shmaddr, 0, MF_REGISTER_shmat);
#endif
return resp;
}
+
+
+#endif /* HAVE_SYS_IPC/SEM/SHM_H */
+
+
+
+/* ctype stuff. This is host-specific by necessity, as the arrays
+ that is used by most is*()/to*() macros are implementation-defined. */
+
+/* GLIBC 2.3 */
+#ifdef HAVE___CTYPE_B_LOC
+WRAPPER2(unsigned short **, __ctype_b_loc, void)
+{
+ static unsigned short * last_buf = (void *) 0;
+ static unsigned short ** last_ptr = (void *) 0;
+ unsigned short ** ptr = (unsigned short **) __ctype_b_loc ();
+ unsigned short * buf = * ptr;
+ if (ptr != last_ptr)
+ {
+ /* XXX: unregister last_ptr? */
+ last_ptr = ptr;
+ __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_b_loc **");
+ }
+ if (buf != last_buf)
+ {
+ last_buf = buf;
+ __mf_register ((void *) (last_buf - 128), 384 * sizeof(unsigned short), __MF_TYPE_STATIC,
+ "ctype_b_loc []");
+ }
+ return ptr;
+}
+#endif
+
+#ifdef HAVE___CTYPE_TOUPPER_LOC
+WRAPPER2(int **, __ctype_toupper_loc, void)
+{
+ static int * last_buf = (void *) 0;
+ static int ** last_ptr = (void *) 0;
+ int ** ptr = (int **) __ctype_toupper_loc ();
+ int * buf = * ptr;
+ if (ptr != last_ptr)
+ {
+ /* XXX: unregister last_ptr? */
+ last_ptr = ptr;
+ __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_toupper_loc **");
+ }
+ if (buf != last_buf)
+ {
+ last_buf = buf;
+ __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC,
+ "ctype_toupper_loc []");
+ }
+ return ptr;
+}
+#endif
+
+#ifdef HAVE___CTYPE_TOLOWER_LOC
+WRAPPER2(int **, __ctype_tolower_loc, void)
+{
+ static int * last_buf = (void *) 0;
+ static int ** last_ptr = (void *) 0;
+ int ** ptr = (int **) __ctype_tolower_loc ();
+ int * buf = * ptr;
+ if (ptr != last_ptr)
+ {
+ /* XXX: unregister last_ptr? */
+ last_ptr = ptr;
+ __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_tolower_loc **");
+ }
+ if (buf != last_buf)
+ {
+ last_buf = buf;
+ __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC,
+ "ctype_tolower_loc []");
+ }
+ return ptr;
+}
+#endif
+
+
+/* passwd/group related functions. These register every (static) pointer value returned,
+ and rely on libmudflap's quiet toleration of duplicate static registrations. */
+
+#ifdef HAVE_GETLOGIN
+WRAPPER2(char *, getlogin, void)
+{
+ char *buf = getlogin ();
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getlogin() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_CUSERID
+WRAPPER2(char *, cuserid, char * buf)
+{
+ if (buf != NULL)
+ {
+ MF_VALIDATE_EXTENT(buf, L_cuserid, __MF_CHECK_WRITE,
+ "cuserid destination");
+ return cuserid (buf);
+ }
+ buf = cuserid (NULL);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getcuserid() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPWNAM
+WRAPPER2(struct passwd *, getpwnam, const char *name)
+{
+ struct passwd *buf;
+ MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+ "getpwnam name");
+ buf = getpwnam (name);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getpw*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPWUID
+WRAPPER2(struct passwd *, getpwuid, uid_t uid)
+{
+ struct passwd *buf;
+ buf = getpwuid (uid);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getpw*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETGRNAM
+WRAPPER2(struct group *, getgrnam, const char *name)
+{
+ struct group *buf;
+ MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+ "getgrnam name");
+ buf = getgrnam (name);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getgr*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETGRGID
+WRAPPER2(struct group *, getgrgid, uid_t uid)
+{
+ struct group *buf;
+ buf = getgrgid (uid);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getgr*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETSERVENT
+WRAPPER2(struct servent *, getservent, void)
+{
+ struct servent *buf;
+ buf = getservent ();
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getserv*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETSERVBYNAME
+WRAPPER2(struct servent *, getservbyname, const char *name, const char *proto)
+{
+ struct servent *buf;
+ MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+ "getservbyname name");
+ MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ,
+ "getservbyname proto");
+ buf = getservbyname (name, proto);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getserv*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETSERVBYPORT
+WRAPPER2(struct servent *, getservbyport, int port, const char *proto)
+{
+ struct servent *buf;
+ MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ,
+ "getservbyport proto");
+ buf = getservbyport (port, proto);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getserv*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GAI_STRERROR
+WRAPPER2(const char *, gai_strerror, int errcode)
+{
+ const char *buf;
+ buf = gai_strerror (errcode);
+ if (buf != NULL)
+ __mf_register ((void *) buf, strlen(buf)+1, __MF_TYPE_STATIC,
+ "gai_strerror() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETMNTENT
+WRAPPER2(struct mntent *, getmntent, FILE *filep)
+{
+ struct mntent *m;
+ static struct mntent *last = NULL;
+
+ MF_VALIDATE_EXTENT (filep, sizeof (*filep), __MF_CHECK_WRITE,
+ "getmntent stream");
+#define UR(field) __mf_unregister(last->field, strlen (last->field)+1, __MF_TYPE_STATIC)
+ if (last)
+ {
+ UR (mnt_fsname);
+ UR (mnt_dir);
+ UR (mnt_type);
+ UR (mnt_opts);
+ __mf_unregister (last, sizeof (*last), __MF_TYPE_STATIC);
+ }
+#undef UR
+
+ m = getmntent (filep);
+ last = m;
+
+#define R(field) __mf_register(last->field, strlen (last->field)+1, __MF_TYPE_STATIC, "mntent " #field)
+ if (m)
+ {
+ R (mnt_fsname);
+ R (mnt_dir);
+ R (mnt_type);
+ R (mnt_opts);
+ __mf_register (last, sizeof (*last), __MF_TYPE_STATIC, "getmntent result");
+ }
+#undef R
+
+ return m;
+}
+#endif
+
+
+#ifdef HAVE_INET_NTOA
+WRAPPER2(char *, inet_ntoa, struct in_addr in)
+{
+ static char *last_buf = NULL;
+ char *buf;
+ if (last_buf)
+ __mf_unregister (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC);
+ buf = inet_ntoa (in);
+ last_buf = buf;
+ if (buf)
+ __mf_register (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC, "inet_ntoa result");
+ return buf;
+}
#endif
+
+#ifdef HAVE_GETPROTOENT
+WRAPPER2(struct protoent *, getprotoent, void)
+{
+ struct protoent *buf;
+ buf = getprotoent ();
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, "getproto*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPROTOBYNAME
+WRAPPER2(struct protoent *, getprotobyname, const char *name)
+{
+ struct protoent *buf;
+ MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+ "getprotobyname name");
+ buf = getprotobyname (name);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getproto*() return");
+ return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPROTOBYNUMBER
+WRAPPER2(struct protoent *, getprotobynumber, int port)
+{
+ struct protoent *buf;
+ buf = getprotobynumber (port);
+ if (buf != NULL)
+ __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+ "getproto*() return");
+ return buf;
+}
+#endif
OSDN Git Service
