libmudflap/mf-hooks2.c

   1 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
   2    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Frank Ch. Eigler <fche@redhat.com>
   4    and Graydon Hoare <graydon@redhat.com>
   5
   6 This file is part of GCC.
   7 XXX: libgcc license?
   8 */
   9
  10 #include "config.h"
  11
  12 /* These attempt to coax various unix flavours to declare all our
  13    needed tidbits in the system headers.  */
  14 #if !defined(__FreeBSD__)
  15 #define _POSIX_SOURCE
  16 #endif /* Some BSDs break <sys/socket.h> if this is defined. */
  17 #define _GNU_SOURCE
  18 #define _XOPEN_SOURCE
  19 #define _BSD_TYPES
  20 #define __EXTENSIONS__
  21
  22 #include <string.h>
  23 #include <strings.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <sys/time.h>
  27 #include <sys/types.h>
  28 #include <unistd.h>
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <limits.h>
  32 #include <time.h>
  33
  34 #include "mf-runtime.h"
  35 #include "mf-impl.h"
  36
  37 #ifdef _MUDFLAP
  38 #error "Do not compile this file with -fmudflap!"
  39 #endif
  40
  41
  42 /* A bunch of independent stdlib/unistd hook functions, all
  43    intercepted by mf-runtime.h macros.  */
  44
  45
  46 /* str*,mem*,b* */
  47
  48 #ifdef WRAP_memcpy
  49 WRAPPER2(void *, memcpy, void *dest, const void *src, size_t n)
  50 {
  51   TRACE ("%s\n", __PRETTY_FUNCTION__);
  52   MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memcpy source");
  53   MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memcpy dest");
  54   return memcpy (dest, src, n);
  55 }
  56 #endif
  57
  58
  59 #ifdef WRAP_memmove
  60 WRAPPER2(void *, memmove, void *dest, const void *src, size_t n)
  61 {
  62   TRACE ("%s\n", __PRETTY_FUNCTION__);
  63   MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memmove src");
  64   MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memmove dest");
  65   return memmove (dest, src, n);
  66 }
  67 #endif
  68
  69 #ifdef WRAP_memset
  70 WRAPPER2(void *, memset, void *s, int c, size_t n)
  71 {
  72   TRACE ("%s\n", __PRETTY_FUNCTION__);
  73   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "memset dest");
  74   return memset (s, c, n);
  75 }
  76 #endif
  77
  78 #ifdef WRAP_memcmp
  79 WRAPPER2(int, memcmp, const void *s1, const void *s2, size_t n)
  80 {
  81   TRACE ("%s\n", __PRETTY_FUNCTION__);
  82   MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "memcmp 1st arg");
  83   MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "memcmp 2nd arg");
  84   return memcmp (s1, s2, n);
  85 }
  86 #endif
  87
  88 #ifdef WRAP_memchr
  89 WRAPPER2(void *, memchr, const void *s, int c, size_t n)
  90 {
  91   TRACE ("%s\n", __PRETTY_FUNCTION__);
  92   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memchr region");
  93   return memchr (s, c, n);
  94 }
  95 #endif
  96
  97 #ifdef WRAP_memrchr
  98 WRAPPER2(void *, memrchr, const void *s, int c, size_t n)
  99 {
 100   TRACE ("%s\n", __PRETTY_FUNCTION__);
 101   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memrchr region");
 102   return memrchr (s, c, n);
 103 }
 104 #endif
 105
 106 #ifdef WRAP_strcpy
 107 WRAPPER2(char *, strcpy, char *dest, const char *src)
 108 {
 109   /* nb: just because strlen(src) == n doesn't mean (src + n) or (src + n +
 110      1) are valid pointers. the allocated object might have size < n.
 111      check anyways. */
 112
 113   size_t n = strlen (src);
 114   TRACE ("%s\n", __PRETTY_FUNCTION__);
 115   MF_VALIDATE_EXTENT(src, CLAMPADD(n, 1), __MF_CHECK_READ, "strcpy src");
 116   MF_VALIDATE_EXTENT(dest, CLAMPADD(n, 1), __MF_CHECK_WRITE, "strcpy dest");
 117   return strcpy (dest, src);
 118 }
 119 #endif
 120
 121 #ifdef WRAP_strncpy
 122 WRAPPER2(char *, strncpy, char *dest, const char *src, size_t n)
 123 {
 124   size_t len = strnlen (src, n);
 125   TRACE ("%s\n", __PRETTY_FUNCTION__);
 126   MF_VALIDATE_EXTENT(src, len, __MF_CHECK_READ, "strncpy src");
 127   MF_VALIDATE_EXTENT(dest, len, __MF_CHECK_WRITE, "strncpy dest"); /* nb: strNcpy */
 128   return strncpy (dest, src, n);
 129 }
 130 #endif
 131
 132 #ifdef WRAP_strcat
 133 WRAPPER2(char *, strcat, char *dest, const char *src)
 134 {
 135   size_t dest_sz;
 136   size_t src_sz;
 137   TRACE ("%s\n", __PRETTY_FUNCTION__);
 138   dest_sz = strlen (dest);
 139   src_sz = strlen (src);
 140   MF_VALIDATE_EXTENT(src, CLAMPADD(src_sz, 1), __MF_CHECK_READ, "strcat src");
 141   MF_VALIDATE_EXTENT(dest, CLAMPADD(dest_sz, CLAMPADD(src_sz, 1)),
 142                      __MF_CHECK_WRITE, "strcat dest");
 143   return strcat (dest, src);
 144 }
 145 #endif
 146
 147 #ifdef WRAP_strncat
 148 WRAPPER2(char *, strncat, char *dest, const char *src, size_t n)
 149 {
 150
 151   /* nb: validating the extents (s,n) might be a mistake for two reasons.
 152
 153   (1) the string s might be shorter than n chars, and n is just a
 154   poor choice by the programmer. this is not a "true" error in the
 155   sense that the call to strncat would still be ok.
 156
 157   (2) we could try to compensate for case (1) by calling strlen(s) and
 158   using that as a bound for the extent to verify, but strlen might fall off
 159   the end of a non-terminated string, leading to a false positive.
 160
 161   so we will call strnlen(s,n) and use that as a bound.
 162
 163   if strnlen returns a length beyond the end of the registered extent
 164   associated with s, there is an error: the programmer's estimate for n is
 165   too large _AND_ the string s is unterminated, in which case they'd be
 166   about to touch memory they don't own while calling strncat.
 167
 168   this same logic applies to further uses of strnlen later down in this
 169   file. */
 170
 171   size_t src_sz;
 172   size_t dest_sz;
 173   TRACE ("%s\n", __PRETTY_FUNCTION__);
 174   src_sz = strnlen (src, n);
 175   dest_sz = strnlen (dest, n);
 176   MF_VALIDATE_EXTENT(src, src_sz, __MF_CHECK_READ, "strncat src");
 177   MF_VALIDATE_EXTENT(dest, (CLAMPADD(dest_sz, CLAMPADD(src_sz, 1))),
 178                      __MF_CHECK_WRITE, "strncat dest");
 179   return strncat (dest, src, n);
 180 }
 181 #endif
 182
 183 #ifdef WRAP_strcmp
 184 WRAPPER2(int, strcmp, const char *s1, const char *s2)
 185 {
 186   size_t s1_sz;
 187   size_t s2_sz;
 188   TRACE ("%s\n", __PRETTY_FUNCTION__);
 189   s1_sz = strlen (s1);
 190   s2_sz = strlen (s2);
 191   MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcmp 1st arg");
 192   MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_WRITE, "strcmp 2nd arg");
 193   return strcmp (s1, s2);
 194 }
 195 #endif
 196
 197 #ifdef WRAP_strcasecmp
 198 WRAPPER2(int, strcasecmp, const char *s1, const char *s2)
 199 {
 200   size_t s1_sz;
 201   size_t s2_sz;
 202   TRACE ("%s\n", __PRETTY_FUNCTION__);
 203   s1_sz = strlen (s1);
 204   s2_sz = strlen (s2);
 205   MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcasecmp 1st arg");
 206   MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_READ, "strcasecmp 2nd arg");
 207   return strcasecmp (s1, s2);
 208 }
 209 #endif
 210
 211 #ifdef WRAP_strncmp
 212 WRAPPER2(int, strncmp, const char *s1, const char *s2, size_t n)
 213 {
 214   size_t s1_sz;
 215   size_t s2_sz;
 216   TRACE ("%s\n", __PRETTY_FUNCTION__);
 217   s1_sz = strnlen (s1, n);
 218   s2_sz = strnlen (s2, n);
 219   MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncmp 1st arg");
 220   MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncmp 2nd arg");
 221   return strncmp (s1, s2, n);
 222 }
 223 #endif
 224
 225 #ifdef WRAP_strncasecmp
 226 WRAPPER2(int, strncasecmp, const char *s1, const char *s2, size_t n)
 227 {
 228   size_t s1_sz;
 229   size_t s2_sz;
 230   TRACE ("%s\n", __PRETTY_FUNCTION__);
 231   s1_sz = strnlen (s1, n);
 232   s2_sz = strnlen (s2, n);
 233   MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncasecmp 1st arg");
 234   MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncasecmp 2nd arg");
 235   return strncasecmp (s1, s2, n);
 236 }
 237 #endif
 238
 239 #ifdef WRAP_strdup
 240 WRAPPER2(char *, strdup, const char *s)
 241 {
 242   DECLARE(void *, malloc, size_t sz);
 243   char *result;
 244   size_t n = strlen (s);
 245   TRACE ("%s\n", __PRETTY_FUNCTION__);
 246   MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strdup region");
 247   result = (char *)CALL_REAL(malloc,
 248                              CLAMPADD(CLAMPADD(n,1),
 249                                       CLAMPADD(__mf_opts.crumple_zone,
 250                                                __mf_opts.crumple_zone)));
 251
 252   if (UNLIKELY(! result)) return result;
 253
 254   result += __mf_opts.crumple_zone;
 255   memcpy (result, s, n);
 256   result[n] = '\0';
 257
 258   __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strdup region");
 259   return result;
 260 }
 261 #endif
 262
 263 #ifdef WRAP_strndup
 264 WRAPPER2(char *, strndup, const char *s, size_t n)
 265 {
 266   DECLARE(void *, malloc, size_t sz);
 267   char *result;
 268   size_t sz = strnlen (s, n);
 269   TRACE ("%s\n", __PRETTY_FUNCTION__);
 270   MF_VALIDATE_EXTENT(s, sz, __MF_CHECK_READ, "strndup region"); /* nb: strNdup */
 271
 272   /* note: strndup still adds a \0, even with the N limit! */
 273   result = (char *)CALL_REAL(malloc,
 274                              CLAMPADD(CLAMPADD(n,1),
 275                                       CLAMPADD(__mf_opts.crumple_zone,
 276                                                __mf_opts.crumple_zone)));
 277
 278   if (UNLIKELY(! result)) return result;
 279
 280   result += __mf_opts.crumple_zone;
 281   memcpy (result, s, n);
 282   result[n] = '\0';
 283
 284   __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strndup region");
 285   return result;
 286 }
 287 #endif
 288
 289 #ifdef WRAP_strchr
 290 WRAPPER2(char *, strchr, const char *s, int c)
 291 {
 292   size_t n;
 293   TRACE ("%s\n", __PRETTY_FUNCTION__);
 294   n = strlen (s);
 295   MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strchr region");
 296   return strchr (s, c);
 297 }
 298 #endif
 299
 300 #ifdef WRAP_strrchr
 301 WRAPPER2(char *, strrchr, const char *s, int c)
 302 {
 303   size_t n;
 304   TRACE ("%s\n", __PRETTY_FUNCTION__);
 305   n = strlen (s);
 306   MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strrchr region");
 307   return strrchr (s, c);
 308 }
 309 #endif
 310
 311 #ifdef WRAP_strstr
 312 WRAPPER2(char *, strstr, const char *haystack, const char *needle)
 313 {
 314   size_t haystack_sz;
 315   size_t needle_sz;
 316   TRACE ("%s\n", __PRETTY_FUNCTION__);
 317   haystack_sz = strlen (haystack);
 318   needle_sz = strlen (needle);
 319   MF_VALIDATE_EXTENT(haystack, CLAMPADD(haystack_sz, 1), __MF_CHECK_READ, "strstr haystack");
 320   MF_VALIDATE_EXTENT(needle, CLAMPADD(needle_sz, 1), __MF_CHECK_READ, "strstr needle");
 321   return strstr (haystack, needle);
 322 }
 323 #endif
 324
 325 #ifdef WRAP_memmem
 326 WRAPPER2(void *, memmem,
 327         const void *haystack, size_t haystacklen,
 328         const void *needle, size_t needlelen)
 329 {
 330   TRACE ("%s\n", __PRETTY_FUNCTION__);
 331   MF_VALIDATE_EXTENT(haystack, haystacklen, __MF_CHECK_READ, "memmem haystack");
 332   MF_VALIDATE_EXTENT(needle, needlelen, __MF_CHECK_READ, "memmem needle");
 333   return memmem (haystack, haystacklen, needle, needlelen);
 334 }
 335 #endif
 336
 337 #ifdef WRAP_strlen
 338 WRAPPER2(size_t, strlen, const char *s)
 339 {
 340   size_t result = strlen (s);
 341   TRACE ("%s\n", __PRETTY_FUNCTION__);
 342   MF_VALIDATE_EXTENT(s, CLAMPADD(result, 1), __MF_CHECK_READ, "strlen region");
 343   return result;
 344 }
 345 #endif
 346
 347 #ifdef WRAP_strnlen
 348 WRAPPER2(size_t, strnlen, const char *s, size_t n)
 349 {
 350   size_t result = strnlen (s, n);
 351   TRACE ("%s\n", __PRETTY_FUNCTION__);
 352   MF_VALIDATE_EXTENT(s, result, __MF_CHECK_READ, "strnlen region");
 353   return result;
 354 }
 355 #endif
 356
 357 #ifdef WRAP_bzero
 358 WRAPPER2(void, bzero, void *s, size_t n)
 359 {
 360   TRACE ("%s\n", __PRETTY_FUNCTION__);
 361   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "bzero region");
 362   bzero (s, n);
 363 }
 364 #endif
 365
 366 #ifdef WRAP_bcopy
 367 #undef bcopy
 368 WRAPPER2(void, bcopy, const void *src, void *dest, size_t n)
 369 {
 370   TRACE ("%s\n", __PRETTY_FUNCTION__);
 371   MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "bcopy src");
 372   MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "bcopy dest");
 373   bcopy (src, dest, n);
 374 }
 375 #endif
 376
 377 #ifdef WRAP_bcmp
 378 #undef bcmp
 379 WRAPPER2(int, bcmp, const void *s1, const void *s2, size_t n)
 380 {
 381   TRACE ("%s\n", __PRETTY_FUNCTION__);
 382   MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "bcmp 1st arg");
 383   MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "bcmp 2nd arg");
 384   return bcmp (s1, s2, n);
 385 }
 386 #endif
 387
 388 #ifdef WRAP_index
 389 WRAPPER2(char *, index, const char *s, int c)
 390 {
 391   size_t n = strlen (s);
 392   TRACE ("%s\n", __PRETTY_FUNCTION__);
 393   MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "index region");
 394   return index (s, c);
 395 }
 396 #endif
 397
 398 #ifdef WRAP_rindex
 399 WRAPPER2(char *, rindex, const char *s, int c)
 400 {
 401   size_t n = strlen (s);
 402   TRACE ("%s\n", __PRETTY_FUNCTION__);
 403   MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "rindex region");
 404   return rindex (s, c);
 405 }
 406 #endif
 407
 408 /* XXX:  stpcpy, memccpy */
 409
 410
 411 /* XXX: *printf,*scanf */
 412
 413
 414 /* XXX: setjmp, longjmp */
 415
 416 #ifdef WRAP_asctime
 417 WRAPPER2(char *, asctime, struct tm *tm)
 418 {
 419   static char *reg_result = NULL;
 420   char *result;
 421   TRACE ("%s\n", __PRETTY_FUNCTION__);
 422   MF_VALIDATE_EXTENT(tm, sizeof (struct tm), __MF_CHECK_READ, "asctime tm");
 423   result = asctime (tm);
 424   if (reg_result == NULL)
 425     {
 426       __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "asctime string");
 427       reg_result = result;
 428     }
 429   return result;
 430 }
 431 #endif
 432
 433 #ifdef WRAP_ctime
 434 WRAPPER2(char *, ctime, const time_t *timep)
 435 {
 436   static char *reg_result = NULL;
 437   char *result;
 438   TRACE ("%s\n", __PRETTY_FUNCTION__);
 439   MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "ctime time");
 440   result = ctime (timep);
 441   if (reg_result == NULL)
 442     {
 443       /* XXX: what if asctime and ctime return the same static ptr? */
 444       __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "ctime string");
 445       reg_result = result;
 446     }
 447   return result;
 448 }
 449 #endif
 450
 451
 452 #ifdef WRAP_localtime
 453 WRAPPER2(struct tm*, localtime, const time_t *timep)
 454 {
 455   static struct tm *reg_result = NULL;
 456   struct tm *result;
 457   TRACE ("%s\n", __PRETTY_FUNCTION__);
 458   MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "localtime time");
 459   result = localtime (timep);
 460   if (reg_result == NULL)
 461     {
 462       __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "localtime tm");
 463       reg_result = result;
 464     }
 465   return result;
 466 }
 467 #endif
 468
 469 #ifdef WRAP_gmtime
 470 WRAPPER2(struct tm*, gmtime, const time_t *timep)
 471 {
 472   static struct tm *reg_result = NULL;
 473   struct tm *result;
 474   TRACE ("%s\n", __PRETTY_FUNCTION__);
 475   MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "gmtime time");
 476   result = gmtime (timep);
 477   if (reg_result == NULL)
 478     {
 479       __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "gmtime tm");
 480       reg_result = result;
 481     }
 482   return result;
 483 }
 484 #endif
 485
 486
 487
 488 /* EL start */
 489
 490 /* The following indicate if the result of the corresponding function
 491  * should be explicitly un/registered by the wrapper
 492 */
 493 #define MF_REGISTER_strerror            __MF_TYPE_STATIC
 494 #undef  MF_REGISTER_fopen
 495 #define MF_RESULT_SIZE_fopen            (sizeof (FILE))
 496 #undef  MF_REGISTER_opendir
 497 #define MF_RESULT_SIZE_opendir          0       /* (sizeof (DIR)) */
 498 #undef  MF_REGISTER_readdir
 499 #define MF_REGISTER_gethostbyname       __MF_TYPE_STATIC
 500 #undef  MF_REGISTER_gethostbyname_items
 501 #undef  MF_REGISTER_dlopen
 502 #undef  MF_REGISTER_dlerror
 503 #undef  MF_REGISTER_dlsym
 504 #define MF_REGISTER_shmat               __MF_TYPE_GUESS
 505
 506
 507 #ifdef WRAP_time
 508 #include <time.h>
 509 WRAPPER2(time_t, time, time_t *timep)
 510 {
 511   TRACE ("%s\n", __PRETTY_FUNCTION__);
 512   if (NULL != timep)
 513     MF_VALIDATE_EXTENT (timep, sizeof (*timep), __MF_CHECK_WRITE,
 514       "time timep");
 515   return time (timep);
 516 }
 517 #endif
 518
 519 #ifdef WRAP_strerror
 520 WRAPPER2(char *, strerror, int errnum)
 521 {
 522   char *p;
 523   size_t n;
 524   TRACE ("%s\n", __PRETTY_FUNCTION__);
 525   p = strerror (errnum);
 526   if (NULL != p) {
 527     n = strlen (p);
 528     n = CLAMPADD(n, 1);
 529 #ifdef MF_REGISTER_strerror
 530     __mf_register (p, n, MF_REGISTER_strerror, "strerror result");
 531 #endif
 532     MF_VALIDATE_EXTENT (p, n, __MF_CHECK_WRITE, "strerror result");
 533   }
 534   return p;
 535 }
 536 #endif
 537
 538 #ifdef WRAP_fopen
 539 WRAPPER2(FILE *, fopen, const char *path, const char *mode)
 540 {
 541   size_t n;
 542   FILE *p;
 543   TRACE ("%s\n", __PRETTY_FUNCTION__);
 544
 545   n = strlen (path);
 546   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen path");
 547
 548   n = strlen (mode);
 549   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen mode");
 550
 551   p = fopen (path, mode);
 552   if (NULL != p) {
 553 #ifdef MF_REGISTER_fopen
 554     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen result");
 555 #endif
 556     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen result");
 557   }
 558
 559   return p;
 560 }
 561 #endif
 562
 563 #ifdef HAVE_FOPEN64
 564 #ifdef WRAP_fopen64
 565 WRAPPER2(FILE *, fopen64, const char *path, const char *mode)
 566 {
 567   size_t n;
 568   FILE *p;
 569   TRACE ("%s\n", __PRETTY_FUNCTION__);
 570
 571   n = strlen (path);
 572   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 path");
 573
 574   n = strlen (mode);
 575   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 mode");
 576
 577   p = fopen64 (path, mode);
 578   if (NULL != p) {
 579 #ifdef MF_REGISTER_fopen
 580     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen64 result");
 581 #endif
 582     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen64 result");
 583   }
 584
 585   return p;
 586 }
 587 #endif
 588 #endif
 589
 590 #ifdef WRAP_fclose
 591 WRAPPER2(int, fclose, FILE *stream)
 592 {
 593   int resp;
 594   TRACE ("%s\n", __PRETTY_FUNCTION__);
 595   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 596     "fclose stream");
 597   resp = fclose (stream);
 598 #ifdef MF_REGISTER_fopen
 599   __mf_unregister (stream, sizeof (*stream));
 600 #endif
 601
 602   return resp;
 603 }
 604 #endif
 605
 606 #ifdef WRAP_fread
 607 WRAPPER2(size_t, fread, void *ptr, size_t size, size_t nmemb, FILE *stream)
 608 {
 609   TRACE ("%s\n", __PRETTY_FUNCTION__);
 610   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 611     "fread stream");
 612   MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_WRITE, "fread buffer");
 613   return fread (ptr, size, nmemb, stream);
 614 }
 615 #endif
 616
 617 #ifdef WRAP_fwrite
 618 WRAPPER2(size_t, fwrite, const void *ptr, size_t size, size_t nmemb,
 619         FILE *stream)
 620 {
 621   TRACE ("%s\n", __PRETTY_FUNCTION__);
 622   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 623     "fwrite stream");
 624   MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_READ, "fwrite buffer");
 625   return fwrite (ptr, size, nmemb, stream);
 626 }
 627 #endif
 628
 629 #ifdef WRAP_fgetc
 630 WRAPPER2(int, fgetc, FILE *stream)
 631 {
 632   TRACE ("%s\n", __PRETTY_FUNCTION__);
 633   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 634     "fgetc stream");
 635   return fgetc (stream);
 636 }
 637 #endif
 638
 639 #ifdef WRAP_fgets
 640 WRAPPER2(char *, fgets, char *s, int size, FILE *stream)
 641 {
 642   TRACE ("%s\n", __PRETTY_FUNCTION__);
 643   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 644     "fgets stream");
 645   MF_VALIDATE_EXTENT (s, size, __MF_CHECK_WRITE, "fgets buffer");
 646   return fgets (s, size, stream);
 647 }
 648 #endif
 649
 650 #ifdef WRAP_getc
 651 WRAPPER2(int, getc, FILE *stream)
 652 {
 653   TRACE ("%s\n", __PRETTY_FUNCTION__);
 654   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 655     "getc stream");
 656   return getc (stream);
 657 }
 658 #endif
 659
 660 #ifdef WRAP_gets
 661 WRAPPER2(char *, gets, char *s)
 662 {
 663   TRACE ("%s\n", __PRETTY_FUNCTION__);
 664   MF_VALIDATE_EXTENT (s, 1, __MF_CHECK_WRITE, "gets buffer");
 665   s = gets (s);
 666   if (NULL != s) {      /* better late than never */
 667     size_t n = strlen (s);
 668     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_WRITE, "gets buffer");
 669   }
 670   return s;
 671 }
 672 #endif
 673
 674 #ifdef WRAP_ungetc
 675 WRAPPER2(int, ungetc, int c, FILE *stream)
 676 {
 677   TRACE ("%s\n", __PRETTY_FUNCTION__);
 678   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 679      "ungetc stream");
 680   return ungetc (c, stream);
 681 }
 682 #endif
 683
 684 #ifdef WRAP_fputc
 685 WRAPPER2(int, fputc, int c, FILE *stream)
 686 {
 687   TRACE ("%s\n", __PRETTY_FUNCTION__);
 688   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 689     "fputc stream");
 690   return fputc (c, stream);
 691 }
 692 #endif
 693
 694 #ifdef WRAP_fputs
 695 WRAPPER2(int, fputs, const char *s, FILE *stream)
 696 {
 697   size_t n;
 698   TRACE ("%s\n", __PRETTY_FUNCTION__);
 699   n = strlen (s);
 700   MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "fputs buffer");
 701   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 702     "fputs stream");
 703   return fputs (s, stream);
 704 }
 705 #endif
 706
 707 #ifdef WRAP_putc
 708 WRAPPER2(int, putc, int c, FILE *stream)
 709 {
 710   TRACE ("%s\n", __PRETTY_FUNCTION__);
 711   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 712     "putc stream");
 713   return putc (c, stream);
 714 }
 715 #endif
 716
 717 #ifdef WRAP_puts
 718 WRAPPER2(int, puts, const char *s)
 719 {
 720   size_t n;
 721   TRACE ("%s\n", __PRETTY_FUNCTION__);
 722   n = strlen (s);
 723   MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "puts buffer");
 724   return puts (s);
 725 }
 726 #endif
 727
 728 #ifdef WRAP_clearerr
 729 WRAPPER2(void, clearerr, FILE *stream)
 730 {
 731   TRACE ("%s\n", __PRETTY_FUNCTION__);
 732   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 733     "clearerr stream");
 734   clearerr (stream);
 735 }
 736 #endif
 737
 738 #ifdef WRAP_feof
 739 WRAPPER2(int, feof, FILE *stream)
 740 {
 741   TRACE ("%s\n", __PRETTY_FUNCTION__);
 742   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 743     "feof stream");
 744   return feof (stream);
 745 }
 746 #endif
 747
 748 #ifdef WRAP_ferror
 749 WRAPPER2(int, ferror, FILE *stream)
 750 {
 751   TRACE ("%s\n", __PRETTY_FUNCTION__);
 752   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 753     "ferror stream");
 754   return ferror (stream);
 755 }
 756 #endif
 757
 758 #ifdef WRAP_fileno
 759 #include <stdio.h>
 760 WRAPPER2(int, fileno, FILE *stream)
 761 {
 762   TRACE ("%s\n", __PRETTY_FUNCTION__);
 763   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 764     "fileno stream");
 765   return fileno (stream);
 766 }
 767 #endif
 768
 769 #ifdef WRAP_printf
 770 #include <stdio.h>
 771 #include <stdarg.h>
 772 WRAPPER2(int, printf, const char *format, ...)
 773 {
 774   size_t n;
 775   va_list ap;
 776   int result;
 777   TRACE ("%s\n", __PRETTY_FUNCTION__);
 778   n = strlen (format);
 779   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 780     "printf format");
 781   va_start (ap, format);
 782   result = vprintf (format, ap);
 783   va_end (ap);
 784   return result;
 785 }
 786 #endif
 787
 788 #ifdef WRAP_fprintf
 789 #include <stdio.h>
 790 #include <stdarg.h>
 791 WRAPPER2(int, fprintf, FILE *stream, const char *format, ...)
 792 {
 793   size_t n;
 794   va_list ap;
 795   int result;
 796   TRACE ("%s\n", __PRETTY_FUNCTION__);
 797   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 798     "fprintf stream");
 799   n = strlen (format);
 800   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 801     "fprintf format");
 802   va_start (ap, format);
 803   result = vfprintf (stream, format, ap);
 804   va_end (ap);
 805   return result;
 806 }
 807 #endif
 808
 809 #ifdef WRAP_sprintf
 810 #include <stdio.h>
 811 #include <stdarg.h>
 812 WRAPPER2(int, sprintf, char *str, const char *format, ...)
 813 {
 814   size_t n;
 815   va_list ap;
 816   int result;
 817   TRACE ("%s\n", __PRETTY_FUNCTION__);
 818   MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "sprintf str");
 819   n = strlen (format);
 820   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 821     "sprintf format");
 822   va_start (ap, format);
 823   result = vsprintf (str, format, ap);
 824   va_end (ap);
 825   n = strlen (str);
 826   MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "sprintf str");
 827   return result;
 828 }
 829 #endif
 830
 831 #ifdef WRAP_snprintf
 832 #include <stdio.h>
 833 #include <stdarg.h>
 834 WRAPPER2(int, snprintf, char *str, size_t size, const char *format, ...)
 835 {
 836   size_t n;
 837   va_list ap;
 838   int result;
 839   TRACE ("%s\n", __PRETTY_FUNCTION__);
 840   MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "snprintf str");
 841   n = strlen (format);
 842   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 843     "snprintf format");
 844   va_start (ap, format);
 845   result = vsnprintf (str, size, format, ap);
 846   va_end (ap);
 847   return result;
 848 }
 849 #endif
 850
 851 #ifdef WRAP_vprintf
 852 #include <stdio.h>
 853 #include <stdarg.h>
 854 WRAPPER2(int, vprintf,  const char *format, va_list ap)
 855 {
 856   size_t n;
 857   TRACE ("%s\n", __PRETTY_FUNCTION__);
 858   n = strlen (format);
 859   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 860     "vprintf format");
 861   return vprintf (format, ap);
 862 }
 863 #endif
 864
 865 #ifdef WRAP_vfprintf
 866 #include <stdio.h>
 867 #include <stdarg.h>
 868 WRAPPER2(int, vfprintf, FILE *stream, const char *format, va_list ap)
 869 {
 870   size_t n;
 871   TRACE ("%s\n", __PRETTY_FUNCTION__);
 872   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 873     "vfprintf stream");
 874   n = strlen (format);
 875   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 876     "vfprintf format");
 877   return vfprintf (stream, format, ap);
 878 }
 879 #endif
 880
 881 #ifdef WRAP_vsprintf
 882 #include <stdio.h>
 883 #include <stdarg.h>
 884 WRAPPER2(int, vsprintf, char *str, const char *format, va_list ap)
 885 {
 886   size_t n;
 887   int result;
 888   TRACE ("%s\n", __PRETTY_FUNCTION__);
 889   MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "vsprintf str");
 890   n = strlen (format);
 891   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 892     "vsprintf format");
 893   result = vsprintf (str, format, ap);
 894   n = strlen (str);
 895   MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "vsprintf str");
 896   return result;
 897 }
 898 #endif
 899
 900 #ifdef WRAP_vsnprintf
 901 #include <stdio.h>
 902 #include <stdarg.h>
 903 WRAPPER2(int, vsnprintf, char *str, size_t size, const char *format,
 904         va_list ap)
 905 {
 906   size_t n;
 907   TRACE ("%s\n", __PRETTY_FUNCTION__);
 908   MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "vsnprintf str");
 909   n = strlen (format);
 910   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
 911     "vsnprintf format");
 912   return vsnprintf (str, size, format, ap);
 913 }
 914 #endif
 915
 916 #ifdef WRAP_access
 917 WRAPPER2(int , access, const char *path, int mode)
 918 {
 919   size_t n;
 920   TRACE ("%s\n", __PRETTY_FUNCTION__);
 921   n = strlen (path);
 922   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "access path");
 923   return access (path, mode);
 924 }
 925 #endif
 926
 927 #ifdef WRAP_remove
 928 WRAPPER2(int , remove, const char *path)
 929 {
 930   size_t n;
 931   TRACE ("%s\n", __PRETTY_FUNCTION__);
 932   n = strlen (path);
 933   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "remove path");
 934   return remove (path);
 935 }
 936 #endif
 937
 938 #ifdef WRAP_fflush
 939 WRAPPER2(int, fflush, FILE *stream)
 940 {
 941   TRACE ("%s\n", __PRETTY_FUNCTION__);
 942   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 943     "fflush stream");
 944   return fflush (stream);
 945 }
 946 #endif
 947
 948 #ifdef WRAP_fseek
 949 WRAPPER2(int, fseek, FILE *stream, long offset, int whence)
 950 {
 951   TRACE ("%s\n", __PRETTY_FUNCTION__);
 952   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 953     "fseek stream");
 954   return fseek (stream, offset, whence);
 955 }
 956 #endif
 957
 958 #ifdef HAVE_FSEEKO64
 959 #ifdef WRAP_fseeko64
 960 WRAPPER2(int, fseeko64, FILE *stream, off64_t offset, int whence)
 961 {
 962   TRACE ("%s\n", __PRETTY_FUNCTION__);
 963   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 964     "fseeko64 stream");
 965   return fseeko64 (stream, offset, whence);
 966 }
 967 #endif
 968 #endif
 969
 970 #ifdef WRAP_ftell
 971 WRAPPER2(long, ftell, FILE *stream)
 972 {
 973   TRACE ("%s\n", __PRETTY_FUNCTION__);
 974   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 975     "ftell stream");
 976   return ftell (stream);
 977 }
 978 #endif
 979
 980 #ifdef HAVE_FTELLO64
 981 #ifdef WRAP_ftello64
 982 WRAPPER2(off64_t, ftello64, FILE *stream)
 983 {
 984   TRACE ("%s\n", __PRETTY_FUNCTION__);
 985   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 986     "ftello64 stream");
 987   return ftello64 (stream);
 988 }
 989 #endif
 990 #endif
 991
 992 #ifdef WRAP_rewind
 993 WRAPPER2(void, rewind, FILE *stream)
 994 {
 995   TRACE ("%s\n", __PRETTY_FUNCTION__);
 996   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 997     "rewind stream");
 998   rewind (stream);
 999 }
1000 #endif
1001
1002 #ifdef WRAP_fgetpos
1003 WRAPPER2(int, fgetpos, FILE *stream, fpos_t *pos)
1004 {
1005   TRACE ("%s\n", __PRETTY_FUNCTION__);
1006   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1007     "fgetpos stream");
1008   MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_WRITE, "fgetpos pos");
1009   return fgetpos (stream, pos);
1010 }
1011 #endif
1012
1013 #ifdef WRAP_fsetpos
1014 WRAPPER2(int, fsetpos, FILE *stream, fpos_t *pos)
1015 {
1016   TRACE ("%s\n", __PRETTY_FUNCTION__);
1017   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1018     "fsetpos stream");
1019   MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_READ, "fsetpos pos");
1020   return fsetpos (stream, pos);
1021 }
1022 #endif
1023
1024 #ifdef WRAP_stat
1025 #include <sys/stat.h>
1026 WRAPPER2(int , stat, const char *path, struct stat *buf)
1027 {
1028   size_t n;
1029   TRACE ("%s\n", __PRETTY_FUNCTION__);
1030   n = strlen (path);
1031   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat path");
1032   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat buf");
1033   return stat (path, buf);
1034 }
1035 #endif
1036
1037 #ifdef HAVE_STAT64
1038 #ifdef WRAP_stat64
1039 #include <sys/stat.h>
1040 WRAPPER2(int , stat64, const char *path, struct stat64 *buf)
1041 {
1042   size_t n;
1043   TRACE ("%s\n", __PRETTY_FUNCTION__);
1044   n = strlen (path);
1045   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat64 path");
1046   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat64 buf");
1047   return stat64 (path, buf);
1048 }
1049 #endif
1050 #endif
1051
1052 #ifdef WRAP_fstat
1053 #include <sys/stat.h>
1054 WRAPPER2(int , fstat, int filedes, struct stat *buf)
1055 {
1056   TRACE ("%s\n", __PRETTY_FUNCTION__);
1057   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "fstat buf");
1058   return fstat (filedes, buf);
1059 }
1060 #endif
1061
1062 #ifdef WRAP_lstat
1063 #include <sys/stat.h>
1064 WRAPPER2(int , lstat, const char *path, struct stat *buf)
1065 {
1066   size_t n;
1067   TRACE ("%s\n", __PRETTY_FUNCTION__);
1068   n = strlen (path);
1069   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "lstat path");
1070   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "lstat buf");
1071   return lstat (path, buf);
1072 }
1073 #endif
1074
1075 #ifdef WRAP_mkfifo
1076 #include <sys/stat.h>
1077 WRAPPER2(int , mkfifo, const char *path, mode_t mode)
1078 {
1079   size_t n;
1080   TRACE ("%s\n", __PRETTY_FUNCTION__);
1081   n = strlen (path);
1082   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "mkfifo path");
1083   return mkfifo (path, mode);
1084 }
1085 #endif
1086
1087 #ifdef WRAP_setvbuf
1088 WRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode , size_t size)
1089 {
1090   TRACE ("%s\n", __PRETTY_FUNCTION__);
1091   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1092     "setvbuf stream");
1093   if (NULL != buf)
1094     MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_READ, "setvbuf buf");
1095   return setvbuf (stream, buf, mode, size);
1096 }
1097 #endif
1098
1099 #ifdef WRAP_setbuf
1100 WRAPPER2(void, setbuf, FILE *stream, char *buf)
1101 {
1102   TRACE ("%s\n", __PRETTY_FUNCTION__);
1103   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1104     "setbuf stream");
1105   if (NULL != buf)
1106     MF_VALIDATE_EXTENT (buf, BUFSIZ, __MF_CHECK_READ, "setbuf buf");
1107   setbuf (stream, buf);
1108 }
1109 #endif
1110
1111 #ifdef WRAP_opendir
1112 #include <dirent.h>
1113 WRAPPER2(DIR *, opendir, const char *path)
1114 {
1115   DIR *p;
1116   size_t n;
1117   TRACE ("%s\n", __PRETTY_FUNCTION__);
1118   n = strlen (path);
1119   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "opendir path");
1120
1121   p = opendir (path);
1122   if (NULL != p) {
1123 #ifdef MF_REGISTER_opendir
1124     __mf_register (p, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir,
1125       "opendir result");
1126 #endif
1127     MF_VALIDATE_EXTENT (p, MF_RESULT_SIZE_opendir, __MF_CHECK_WRITE,
1128       "opendir result");
1129   }
1130   return p;
1131 }
1132 #endif
1133
1134 #ifdef WRAP_closedir
1135 #include <dirent.h>
1136 WRAPPER2(int, closedir, DIR *dir)
1137 {
1138   TRACE ("%s\n", __PRETTY_FUNCTION__);
1139   MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_WRITE, "closedir dir");
1140 #ifdef MF_REGISTER_opendir
1141   __mf_unregister (dir, MF_RESULT_SIZE_opendir);
1142 #endif
1143   return closedir (dir);
1144 }
1145 #endif
1146
1147 #ifdef WRAP_readdir
1148 #include <dirent.h>
1149 WRAPPER2(struct dirent *, readdir, DIR *dir)
1150 {
1151   struct dirent *p;
1152   TRACE ("%s\n", __PRETTY_FUNCTION__);
1153   MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_READ, "readdir dir");
1154   p = readdir (dir);
1155   if (NULL != p) {
1156 #ifdef MF_REGISTER_readdir
1157     __mf_register (p, sizeof (*p), MF_REGISTER_readdir, "readdir result");
1158 #endif
1159     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "readdir result");
1160   }
1161   return p;
1162 }
1163 #endif
1164
1165 #ifdef WRAP_recv
1166 #include <sys/socket.h>
1167 WRAPPER2(int, recv, int s, void *buf, size_t len, int flags)
1168 {
1169   TRACE ("%s\n", __PRETTY_FUNCTION__);
1170   MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recv buf");
1171   return recv (s, buf, len, flags);
1172 }
1173 #endif
1174
1175 #ifdef WRAP_recvfrom
1176 #include <sys/socket.h>
1177 WRAPPER2(int, recvfrom, int s, void *buf, size_t len, int flags,
1178                 struct sockaddr *from, socklen_t *fromlen)
1179 {
1180   TRACE ("%s\n", __PRETTY_FUNCTION__);
1181   MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recvfrom buf");
1182   MF_VALIDATE_EXTENT (from, (size_t)*fromlen, __MF_CHECK_WRITE,
1183     "recvfrom from");
1184   return recvfrom (s, buf, len, flags, from, fromlen);
1185 }
1186 #endif
1187
1188 #ifdef WRAP_recvmsg
1189 #include <sys/socket.h>
1190 WRAPPER2(int, recvmsg, int s, struct msghdr *msg, int flags)
1191 {
1192   TRACE ("%s\n", __PRETTY_FUNCTION__);
1193   MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_WRITE, "recvmsg msg");
1194   return recvmsg (s, msg, flags);
1195 }
1196 #endif
1197
1198 #ifdef WRAP_send
1199 #include <sys/socket.h>
1200 WRAPPER2(int, send, int s, const void *msg, size_t len, int flags)
1201 {
1202   TRACE ("%s\n", __PRETTY_FUNCTION__);
1203   MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "send msg");
1204   return send (s, msg, len, flags);
1205 }
1206 #endif
1207
1208 #ifdef WRAP_sendto
1209 #include <sys/socket.h>
1210 WRAPPER2(int, sendto, int s, const void *msg, size_t len, int flags,
1211                 const struct sockaddr *to, socklen_t tolen)
1212 {
1213   TRACE ("%s\n", __PRETTY_FUNCTION__);
1214   MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "sendto msg");
1215   MF_VALIDATE_EXTENT (to, (size_t)tolen, __MF_CHECK_WRITE, "sendto to");
1216   return sendto (s, msg, len, flags, to, tolen);
1217 }
1218 #endif
1219
1220 #ifdef WRAP_sendmsg
1221 #include <sys/socket.h>
1222 WRAPPER2(int, sendmsg, int s, const void *msg, int flags)
1223 {
1224   TRACE ("%s\n", __PRETTY_FUNCTION__);
1225   MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_READ, "sendmsg msg");
1226   return sendmsg (s, msg, flags);
1227 }
1228 #endif
1229
1230 #ifdef WRAP_setsockopt
1231 #include <sys/socket.h>
1232 WRAPPER2(int, setsockopt, int s, int level, int optname, const void *optval,
1233         socklen_t optlen)
1234 {
1235   TRACE ("%s\n", __PRETTY_FUNCTION__);
1236   MF_VALIDATE_EXTENT (optval, (size_t)optlen, __MF_CHECK_READ,
1237     "setsockopt optval");
1238   return setsockopt (s, level, optname, optval, optlen);
1239 }
1240 #endif
1241
1242 #ifdef WRAP_getsockopt
1243 #include <sys/socket.h>
1244 WRAPPER2(int, getsockopt, int s, int level, int optname, void *optval,
1245                 socklen_t *optlen)
1246 {
1247   TRACE ("%s\n", __PRETTY_FUNCTION__);
1248   MF_VALIDATE_EXTENT (optval, (size_t)*optlen, __MF_CHECK_WRITE,
1249     "getsockopt optval");
1250   return getsockopt (s, level, optname, optval, optlen);
1251 }
1252 #endif
1253
1254 #ifdef WRAP_accept
1255 #include <sys/socket.h>
1256 WRAPPER2(int, accept, int s, struct  sockaddr *addr, socklen_t *addrlen)
1257 {
1258   TRACE ("%s\n", __PRETTY_FUNCTION__);
1259   MF_VALIDATE_EXTENT (addr, (size_t)*addrlen, __MF_CHECK_WRITE, "accept addr");
1260   return accept (s, addr, addrlen);
1261 }
1262 #endif
1263
1264 #ifdef WRAP_bind
1265 #include <sys/socket.h>
1266 WRAPPER2(int, bind, int sockfd, struct  sockaddr *addr, socklen_t addrlen)
1267 {
1268   TRACE ("%s\n", __PRETTY_FUNCTION__);
1269   MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_WRITE, "bind addr");
1270   return bind (sockfd, addr, addrlen);
1271 }
1272 #endif
1273
1274 #ifdef WRAP_connect
1275 #include <sys/socket.h>
1276 WRAPPER2(int, connect, int sockfd, const struct sockaddr  *addr,
1277         socklen_t addrlen)
1278 {
1279   TRACE ("%s\n", __PRETTY_FUNCTION__);
1280   MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_READ,
1281     "connect addr");
1282   return connect (sockfd, addr, addrlen);
1283 }
1284 #endif
1285
1286 #ifdef WRAP_gethostname
1287 WRAPPER2(int, gethostname, char *name, size_t len)
1288 {
1289   TRACE ("%s\n", __PRETTY_FUNCTION__);
1290   MF_VALIDATE_EXTENT (name, len, __MF_CHECK_WRITE, "gethostname name");
1291   return gethostname (name, len);
1292 }
1293 #endif
1294
1295 #ifdef WRAP_sethostname
1296 WRAPPER2(int, sethostname, const char *name, size_t len)
1297 {
1298   TRACE ("%s\n", __PRETTY_FUNCTION__);
1299   MF_VALIDATE_EXTENT (name, len, __MF_CHECK_READ, "sethostname name");
1300   return sethostname (name, len);
1301 }
1302 #endif
1303
1304 #ifdef WRAP_gethostbyname
1305 #include <netdb.h>
1306 WRAPPER2(struct hostent *, gethostbyname, const char *name)
1307 {
1308   struct hostent *p;
1309   char **ss;
1310   char *s;
1311   size_t n;
1312   int nreg;
1313   TRACE ("%s\n", __PRETTY_FUNCTION__);
1314   n = strlen (name);
1315   MF_VALIDATE_EXTENT (name, CLAMPADD(n, 1), __MF_CHECK_READ,
1316     "gethostbyname name");
1317   p = gethostbyname (name);
1318   if (NULL != p) {
1319 #ifdef MF_REGISTER_gethostbyname
1320     __mf_register (p, sizeof (*p), MF_REGISTER_gethostbyname,
1321       "gethostbyname result");
1322 #endif
1323     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE,
1324       "gethostbyname result");
1325     if (NULL != (s = p->h_name)) {
1326       n = strlen (s);
1327       n = CLAMPADD(n, 1);
1328 #ifdef MF_REGISTER_gethostbyname_items
1329       __mf_register (s, n, MF_REGISTER_gethostbyname_items,
1330         "gethostbyname result->h_name");
1331 #endif
1332       MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE,
1333         "gethostbyname result->h_name");
1334     }
1335
1336     if (NULL != (ss = p->h_aliases)) {
1337       for (nreg = 1;; ++nreg) {
1338         s = *ss++;
1339         if (NULL == s)
1340           break;
1341         n = strlen (s);
1342         n = CLAMPADD(n, 1);
1343 #ifdef MF_REGISTER_gethostbyname_items
1344         __mf_register (s, n, MF_REGISTER_gethostbyname_items,
1345           "gethostbyname result->h_aliases[]");
1346 #endif
1347         MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE,
1348           "gethostbyname result->h_aliases[]");
1349       }
1350       nreg *= sizeof (*p->h_aliases);
1351 #ifdef MF_REGISTER_gethostbyname_items
1352       __mf_register (p->h_aliases, nreg, MF_REGISTER_gethostbyname_items,
1353         "gethostbyname result->h_aliases");
1354 #endif
1355       MF_VALIDATE_EXTENT (p->h_aliases, nreg, __MF_CHECK_WRITE,
1356         "gethostbyname result->h_aliases");
1357     }
1358
1359     if (NULL != (ss = p->h_addr_list)) {
1360       for (nreg = 1;; ++nreg) {
1361         s = *ss++;
1362         if (NULL == s)
1363           break;
1364 #ifdef MF_REGISTER_gethostbyname_items
1365         __mf_register (s, p->h_length, MF_REGISTER_gethostbyname_items,
1366           "gethostbyname result->h_addr_list[]");
1367 #endif
1368         MF_VALIDATE_EXTENT (s, p->h_length, __MF_CHECK_WRITE,
1369           "gethostbyname result->h_addr_list[]");
1370       }
1371       nreg *= sizeof (*p->h_addr_list);
1372 #ifdef MF_REGISTER_gethostbyname_items
1373       __mf_register (p->h_addr_list, nreg, MF_REGISTER_gethostbyname_items,
1374         "gethostbyname result->h_addr_list");
1375 #endif
1376       MF_VALIDATE_EXTENT (p->h_addr_list, nreg, __MF_CHECK_WRITE,
1377         "gethostbyname result->h_addr_list");
1378     }
1379   }
1380   return p;
1381 }
1382 #endif
1383
1384 #ifdef WRAP_wait
1385 #include <sys/wait.h>
1386 WRAPPER2(pid_t, wait, int *status)
1387 {
1388   TRACE ("%s\n", __PRETTY_FUNCTION__);
1389   if (NULL != status)
1390     MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE,
1391       "wait status");
1392   return wait (status);
1393 }
1394 #endif
1395
1396 #ifdef WRAP_waitpid
1397 #include <sys/wait.h>
1398 WRAPPER2(pid_t, waitpid, pid_t pid, int *status, int options)
1399 {
1400   TRACE ("%s\n", __PRETTY_FUNCTION__);
1401   if (NULL != status)
1402     MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE,
1403       "waitpid status");
1404   return waitpid (pid, status, options);
1405 }
1406 #endif
1407
1408 #ifdef WRAP_popen
1409 WRAPPER2(FILE *, popen, const char *command, const char *mode)
1410 {
1411   size_t n;
1412   FILE *p;
1413   TRACE ("%s\n", __PRETTY_FUNCTION__);
1414
1415   n = strlen (command);
1416   MF_VALIDATE_EXTENT (command, CLAMPADD(n, 1), __MF_CHECK_READ, "popen path");
1417
1418   n = strlen (mode);
1419   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "popen mode");
1420
1421   p = popen (command, mode);
1422   if (NULL != p) {
1423 #ifdef MF_REGISTER_fopen
1424     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "popen result");
1425 #endif
1426     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "popen result");
1427   }
1428   return p;
1429 }
1430 #endif
1431
1432 #ifdef WRAP_pclose
1433 WRAPPER2(int, pclose, FILE *stream)
1434 {
1435   int resp;
1436   TRACE ("%s\n", __PRETTY_FUNCTION__);
1437   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1438     "pclose stream");
1439   resp = pclose (stream);
1440 #ifdef MF_REGISTER_fopen
1441   __mf_unregister (stream, sizeof (*stream));
1442 #endif
1443   return resp;
1444 }
1445 #endif
1446
1447 #ifdef WRAP_execve
1448 WRAPPER2(int, execve, const char *path, char *const argv [],
1449         char *const envp[])
1450 {
1451   size_t n;
1452   char *const *p;
1453   const char *s;
1454   TRACE ("%s\n", __PRETTY_FUNCTION__);
1455
1456   n = strlen (path);
1457   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execve path");
1458
1459   for (p = argv;;) {
1460     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *argv");
1461     s = *p++;
1462     if (NULL == s)
1463       break;
1464     n = strlen (s);
1465     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **argv");
1466   }
1467
1468   for (p = envp;;) {
1469     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *envp");
1470     s = *p++;
1471     if (NULL == s)
1472       break;
1473     n = strlen (s);
1474     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **envp");
1475   }
1476   return execve (path, argv, envp);
1477 }
1478 #endif
1479
1480 #ifdef WRAP_execv
1481 WRAPPER2(int, execv, const char *path, char *const argv [])
1482 {
1483   size_t n;
1484   char *const *p;
1485   const char *s;
1486   TRACE ("%s\n", __PRETTY_FUNCTION__);
1487
1488   n = strlen (path);
1489   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execv path");
1490
1491   for (p = argv;;) {
1492     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execv *argv");
1493     s = *p++;
1494     if (NULL == s)
1495       break;
1496     n = strlen (s);
1497     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execv **argv");
1498   }
1499   return execv (path, argv);
1500 }
1501 #endif
1502
1503 #ifdef WRAP_execvp
1504 WRAPPER2(int, execvp, const char *path, char *const argv [])
1505 {
1506   size_t n;
1507   char *const *p;
1508   const char *s;
1509   TRACE ("%s\n", __PRETTY_FUNCTION__);
1510
1511   n = strlen (path);
1512   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp path");
1513
1514   for (p = argv;;) {
1515     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execvp *argv");
1516     s = *p++;
1517     if (NULL == s)
1518       break;
1519     n = strlen (s);
1520     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp **argv");
1521   }
1522   return execvp (path, argv);
1523 }
1524 #endif
1525
1526 #ifdef WRAP_system
1527 WRAPPER2(int, system, const char *string)
1528 {
1529   size_t n;
1530   TRACE ("%s\n", __PRETTY_FUNCTION__);
1531   n = strlen (string);
1532   MF_VALIDATE_EXTENT (string, CLAMPADD(n, 1), __MF_CHECK_READ,
1533     "system string");
1534   return system (string);
1535 }
1536 #endif
1537
1538 #ifdef WRAP_dlopen
1539 WRAPPER2(void *, dlopen, const char *path, int flags)
1540 {
1541   void *p;
1542   size_t n;
1543   TRACE ("%s\n", __PRETTY_FUNCTION__);
1544   n = strlen (path);
1545   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "dlopen path");
1546   p = dlopen (path, flags);
1547   if (NULL != p) {
1548 #ifdef MF_REGISTER_dlopen
1549     __mf_register (p, 0, MF_REGISTER_dlopen, "dlopen result");
1550 #endif
1551     MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlopen result");
1552   }
1553   return p;
1554 }
1555 #endif
1556
1557 #ifdef WRAP_dlclose
1558 WRAPPER2(int, dlclose, void *handle)
1559 {
1560   int resp;
1561   TRACE ("%s\n", __PRETTY_FUNCTION__);
1562   MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlclose handle");
1563   resp = dlclose (handle);
1564 #ifdef MF_REGISTER_dlopen
1565   __mf_unregister (handle, 0);
1566 #endif
1567   return resp;
1568 }
1569 #endif
1570
1571 #ifdef WRAP_dlerror
1572 WRAPPER2(char *, dlerror)
1573 {
1574   char *p;
1575   TRACE ("%s\n", __PRETTY_FUNCTION__);
1576   p = dlerror ();
1577   if (NULL != p) {
1578     size_t n;
1579     n = strlen (p);
1580     n = CLAMPADD(n, 1);
1581 #ifdef MF_REGISTER_dlerror
1582     __mf_register (p, n, MF_REGISTER_dlerror, "dlerror result");
1583 #endif
1584     MF_VALIDATE_EXTENT (p, n, __MF_CHECK_WRITE, "dlerror result");
1585   }
1586   return p;
1587 }
1588 #endif
1589
1590 #ifdef WRAP_dlsym
1591 WRAPPER2(void *, dlsym, void *handle, char *symbol)
1592 {
1593   size_t n;
1594   void *p;
1595   TRACE ("%s\n", __PRETTY_FUNCTION__);
1596   MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlsym handle");
1597   n = strlen (symbol);
1598   MF_VALIDATE_EXTENT (symbol, CLAMPADD(n, 1), __MF_CHECK_READ, "dlsym symbol");
1599   p = dlsym (handle, symbol);
1600   if (NULL != p) {
1601 #ifdef MF_REGISTER_dlsym
1602     __mf_register (p, 0, MF_REGISTER_dlsym, "dlsym result");
1603 #endif
1604     MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlsym result");
1605   }
1606   return p;
1607 }
1608 #endif
1609
1610 #ifdef WRAP_semop
1611 #include <sys/ipc.h>
1612 #include <sys/sem.h>
1613 WRAPPER2(int, semop, int semid, struct sembuf *sops, unsigned nsops)
1614 {
1615   TRACE ("%s\n", __PRETTY_FUNCTION__);
1616   MF_VALIDATE_EXTENT (sops, sizeof (*sops) * nsops, __MF_CHECK_READ,
1617     "semop sops");
1618   return semop (semid, sops, nsops);
1619 }
1620 #endif
1621
1622 #ifdef WRAP_semctl
1623 #include <sys/ipc.h>
1624 #include <sys/sem.h>
1625 #ifndef HAVE_UNION_SEMUN
1626 union semun {
1627         int val;                        /* value for SETVAL */
1628         struct semid_ds *buf;           /* buffer for IPC_STAT, IPC_SET */
1629         unsigned short int *array;      /* array for GETALL, SETALL */
1630         struct seminfo *__buf;          /* buffer for IPC_INFO */
1631 };
1632 #endif
1633 WRAPPER2(int, semctl, int semid, int semnum, int cmd, union semun arg)
1634 {
1635   TRACE ("%s\n", __PRETTY_FUNCTION__);
1636   switch (cmd) {
1637   case IPC_STAT:
1638     MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_WRITE,
1639       "semctl buf");
1640     break;
1641   case IPC_SET:
1642     MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_READ,
1643       "semctl buf");
1644     break;
1645   case GETALL:
1646     MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_WRITE,
1647       "semctl array");
1648   case SETALL:
1649     MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_READ,
1650       "semctl array");
1651     break;
1652 #ifdef IPC_INFO
1653   case IPC_INFO:
1654     MF_VALIDATE_EXTENT (arg.__buf, sizeof (*arg.__buf), __MF_CHECK_WRITE,
1655       "semctl __buf");
1656     break;
1657 #endif
1658   default:
1659     break;
1660   }
1661   return semctl (semid, semnum, cmd, arg);
1662 }
1663 #endif
1664
1665 #ifdef WRAP_shmctl
1666 #include <sys/ipc.h>
1667 #include <sys/shm.h>
1668 WRAPPER2(int, shmctl, int shmid, int cmd, struct shmid_ds *buf)
1669 {
1670   TRACE ("%s\n", __PRETTY_FUNCTION__);
1671   switch (cmd) {
1672   case IPC_STAT:
1673     MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_WRITE,
1674       "shmctl buf");
1675     break;
1676   case IPC_SET:
1677     MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ,
1678       "shmctl buf");
1679     break;
1680   default:
1681     break;
1682   }
1683   return shmctl (shmid, cmd, buf);
1684 }
1685 #endif
1686
1687 #ifdef WRAP_shmat
1688 #include <sys/ipc.h>
1689 #include <sys/shm.h>
1690 WRAPPER2(void *, shmat, int shmid, const void *shmaddr, int shmflg)
1691 {
1692   void *p;
1693   TRACE ("%s\n", __PRETTY_FUNCTION__);
1694   p = shmat (shmid, shmaddr, shmflg);
1695 #ifdef MF_REGISTER_shmat
1696   if (NULL != p) {
1697     struct shmid_ds buf;
1698     __mf_register (p, shmctl (shmid, IPC_STAT, &buf) ? 0 : buf.shm_segsz,
1699       MF_REGISTER_shmat, "shmat result");
1700   }
1701 #endif
1702   return p;
1703 }
1704 #endif
1705
1706 #ifdef WRAP_shmdt
1707 #include <sys/ipc.h>
1708 #include <sys/shm.h>
1709 WRAPPER2(int, shmdt, const void *shmaddr)
1710 {
1711   int resp;
1712   TRACE ("%s\n", __PRETTY_FUNCTION__);
1713   resp = shmdt (shmaddr);
1714 #ifdef MF_REGISTER_shmat
1715   __mf_unregister ((void *)shmaddr, 0);
1716 #endif
1717   return resp;
1718 }
1719 #endif
1720