libmudflap/mf-hooks2.c

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