libmudflap/mf-hooks2.c

   1 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
   2    Copyright (C) 2002, 2003, 2004, 2009 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 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 Under Section 7 of GPL version 3, you are granted additional
  19 permissions described in the GCC Runtime Library Exception, version
  20 3.1, as published by the Free Software Foundation.
  21
  22 You should have received a copy of the GNU General Public License and
  23 a copy of the GCC Runtime Library Exception along with this program;
  24 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 <http://www.gnu.org/licenses/>.  */
  26
  27 #include "config.h"
  28
  29 #ifndef HAVE_SOCKLEN_T
  30 #define socklen_t int
  31 #endif
  32
  33 /* These attempt to coax various unix flavours to declare all our
  34    needed tidbits in the system headers.  */
  35 #if !defined(__FreeBSD__) && !defined(__APPLE__)
  36 #define _POSIX_SOURCE
  37 #endif /* Some BSDs break <sys/socket.h> if this is defined. */
  38 #define _GNU_SOURCE
  39 #define _XOPEN_SOURCE
  40 #define _BSD_TYPES
  41 #define __EXTENSIONS__
  42 #define _ALL_SOURCE
  43 #define _LARGE_FILE_API
  44 #define _LARGEFILE64_SOURCE
  45 #define _XOPEN_SOURCE_EXTENDED 1
  46
  47 #include <string.h>
  48 #include <stdarg.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <sys/stat.h>
  52 #include <sys/time.h>
  53 #include <sys/types.h>
  54 #include <unistd.h>
  55 #include <assert.h>
  56 #include <errno.h>
  57 #include <limits.h>
  58 #include <time.h>
  59 #include <ctype.h>
  60 #ifdef HAVE_DLFCN_H
  61 #include <dlfcn.h>
  62 #endif
  63 #ifdef HAVE_DIRENT_H
  64 #include <dirent.h>
  65 #endif
  66 #ifdef HAVE_SYS_SOCKET_H
  67 #include <sys/socket.h>
  68 #endif
  69 #ifdef HAVE_NETDB_H
  70 #include <netdb.h>
  71 #endif
  72 #ifdef HAVE_SYS_WAIT_H
  73 #include <sys/wait.h>
  74 #endif
  75 #ifdef HAVE_SYS_IPC_H
  76 #include <sys/ipc.h>
  77 #endif
  78 #ifdef HAVE_SYS_SEM_H
  79 #include <sys/sem.h>
  80 #endif
  81 #ifdef HAVE_SYS_SHM_H
  82 #include <sys/shm.h>
  83 #endif
  84 #ifdef HAVE_PWD_H
  85 #include <pwd.h>
  86 #endif
  87 #ifdef HAVE_GRP_H
  88 #include <grp.h>
  89 #endif
  90 #ifdef HAVE_MNTENT_H
  91 #include <mntent.h>
  92 #endif
  93 #ifdef HAVE_SYS_SOCKET_H
  94 #include <sys/socket.h>
  95 #endif
  96 #ifdef HAVE_NETINET_IN_H
  97 #include <netinet/in.h>
  98 #endif
  99 #ifdef HAVE_ARPA_INET_H
 100 #include <arpa/inet.h>
 101 #endif
 102
 103 #include "mf-runtime.h"
 104 #include "mf-impl.h"
 105
 106 #ifdef _MUDFLAP
 107 #error "Do not compile this file with -fmudflap!"
 108 #endif
 109
 110
 111 /* A bunch of independent stdlib/unistd hook functions, all
 112    intercepted by mf-runtime.h macros.  */
 113
 114 #ifndef HAVE_STRNLEN
 115 static inline size_t (strnlen) (const char* str, size_t n)
 116 {
 117   const char *s;
 118
 119   for (s = str; n && *s; ++s, --n)
 120     ;
 121   return (s - str);
 122 }
 123 #endif
 124
 125
 126 /* str*,mem*,b* */
 127
 128 WRAPPER2(void *, memcpy, void *dest, const void *src, size_t n)
 129 {
 130   TRACE ("%s\n", __PRETTY_FUNCTION__);
 131   MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memcpy source");
 132   MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memcpy dest");
 133   return memcpy (dest, src, n);
 134 }
 135
 136
 137 WRAPPER2(void *, memmove, void *dest, const void *src, size_t n)
 138 {
 139   TRACE ("%s\n", __PRETTY_FUNCTION__);
 140   MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memmove src");
 141   MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memmove dest");
 142   return memmove (dest, src, n);
 143 }
 144
 145
 146 WRAPPER2(void *, memset, void *s, int c, size_t n)
 147 {
 148   TRACE ("%s\n", __PRETTY_FUNCTION__);
 149   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "memset dest");
 150   return memset (s, c, n);
 151 }
 152
 153
 154 WRAPPER2(int, memcmp, const void *s1, const void *s2, size_t n)
 155 {
 156   TRACE ("%s\n", __PRETTY_FUNCTION__);
 157   MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "memcmp 1st arg");
 158   MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "memcmp 2nd arg");
 159   return memcmp (s1, s2, n);
 160 }
 161
 162
 163 WRAPPER2(void *, memchr, const void *s, int c, size_t n)
 164 {
 165   TRACE ("%s\n", __PRETTY_FUNCTION__);
 166   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memchr region");
 167   return memchr (s, c, n);
 168 }
 169
 170
 171 #ifdef HAVE_MEMRCHR
 172 WRAPPER2(void *, memrchr, const void *s, int c, size_t n)
 173 {
 174   TRACE ("%s\n", __PRETTY_FUNCTION__);
 175   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memrchr region");
 176   return memrchr (s, c, n);
 177 }
 178 #endif
 179
 180
 181 WRAPPER2(char *, strcpy, char *dest, const char *src)
 182 {
 183   /* nb: just because strlen(src) == n doesn't mean (src + n) or (src + n +
 184      1) are valid pointers. the allocated object might have size < n.
 185      check anyways. */
 186
 187   size_t n = strlen (src);
 188   TRACE ("%s\n", __PRETTY_FUNCTION__);
 189   MF_VALIDATE_EXTENT(src, CLAMPADD(n, 1), __MF_CHECK_READ, "strcpy src");
 190   MF_VALIDATE_EXTENT(dest, CLAMPADD(n, 1), __MF_CHECK_WRITE, "strcpy dest");
 191   return strcpy (dest, src);
 192 }
 193
 194
 195 #ifdef HAVE_STRNCPY
 196 WRAPPER2(char *, strncpy, char *dest, const char *src, size_t n)
 197 {
 198   size_t len = strnlen (src, n);
 199   TRACE ("%s\n", __PRETTY_FUNCTION__);
 200   MF_VALIDATE_EXTENT(src, len, __MF_CHECK_READ, "strncpy src");
 201   MF_VALIDATE_EXTENT(dest, len, __MF_CHECK_WRITE, "strncpy dest"); /* nb: strNcpy */
 202   return strncpy (dest, src, n);
 203 }
 204 #endif
 205
 206
 207 WRAPPER2(char *, strcat, char *dest, const char *src)
 208 {
 209   size_t dest_sz;
 210   size_t src_sz;
 211   TRACE ("%s\n", __PRETTY_FUNCTION__);
 212   dest_sz = strlen (dest);
 213   src_sz = strlen (src);
 214   MF_VALIDATE_EXTENT(src, CLAMPADD(src_sz, 1), __MF_CHECK_READ, "strcat src");
 215   MF_VALIDATE_EXTENT(dest, CLAMPADD(dest_sz, CLAMPADD(src_sz, 1)),
 216                      __MF_CHECK_WRITE, "strcat dest");
 217   return strcat (dest, src);
 218 }
 219
 220
 221 WRAPPER2(char *, strncat, char *dest, const char *src, size_t n)
 222 {
 223
 224   /* nb: validating the extents (s,n) might be a mistake for two reasons.
 225
 226   (1) the string s might be shorter than n chars, and n is just a
 227   poor choice by the programmer. this is not a "true" error in the
 228   sense that the call to strncat would still be ok.
 229
 230   (2) we could try to compensate for case (1) by calling strlen(s) and
 231   using that as a bound for the extent to verify, but strlen might fall off
 232   the end of a non-terminated string, leading to a false positive.
 233
 234   so we will call strnlen(s,n) and use that as a bound.
 235
 236   if strnlen returns a length beyond the end of the registered extent
 237   associated with s, there is an error: the programmer's estimate for n is
 238   too large _AND_ the string s is unterminated, in which case they'd be
 239   about to touch memory they don't own while calling strncat.
 240
 241   this same logic applies to further uses of strnlen later down in this
 242   file. */
 243
 244   size_t src_sz;
 245   size_t dest_sz;
 246   TRACE ("%s\n", __PRETTY_FUNCTION__);
 247   src_sz = strnlen (src, n);
 248   dest_sz = strnlen (dest, n);
 249   MF_VALIDATE_EXTENT(src, src_sz, __MF_CHECK_READ, "strncat src");
 250   MF_VALIDATE_EXTENT(dest, (CLAMPADD(dest_sz, CLAMPADD(src_sz, 1))),
 251                      __MF_CHECK_WRITE, "strncat dest");
 252   return strncat (dest, src, n);
 253 }
 254
 255
 256 WRAPPER2(int, strcmp, const char *s1, const char *s2)
 257 {
 258   size_t s1_sz;
 259   size_t s2_sz;
 260   TRACE ("%s\n", __PRETTY_FUNCTION__);
 261   s1_sz = strlen (s1);
 262   s2_sz = strlen (s2);
 263   MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcmp 1st arg");
 264   MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_WRITE, "strcmp 2nd arg");
 265   return strcmp (s1, s2);
 266 }
 267
 268
 269 WRAPPER2(int, strcasecmp, const char *s1, const char *s2)
 270 {
 271   size_t s1_sz;
 272   size_t s2_sz;
 273   TRACE ("%s\n", __PRETTY_FUNCTION__);
 274   s1_sz = strlen (s1);
 275   s2_sz = strlen (s2);
 276   MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcasecmp 1st arg");
 277   MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_READ, "strcasecmp 2nd arg");
 278   return strcasecmp (s1, s2);
 279 }
 280
 281
 282 WRAPPER2(int, strncmp, const char *s1, const char *s2, size_t n)
 283 {
 284   size_t s1_sz;
 285   size_t s2_sz;
 286   TRACE ("%s\n", __PRETTY_FUNCTION__);
 287   s1_sz = strnlen (s1, n);
 288   s2_sz = strnlen (s2, n);
 289   MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncmp 1st arg");
 290   MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncmp 2nd arg");
 291   return strncmp (s1, s2, n);
 292 }
 293
 294
 295 WRAPPER2(int, strncasecmp, const char *s1, const char *s2, size_t n)
 296 {
 297   size_t s1_sz;
 298   size_t s2_sz;
 299   TRACE ("%s\n", __PRETTY_FUNCTION__);
 300   s1_sz = strnlen (s1, n);
 301   s2_sz = strnlen (s2, n);
 302   MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncasecmp 1st arg");
 303   MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncasecmp 2nd arg");
 304   return strncasecmp (s1, s2, n);
 305 }
 306
 307
 308 WRAPPER2(char *, strdup, const char *s)
 309 {
 310   DECLARE(void *, malloc, size_t sz);
 311   char *result;
 312   size_t n = strlen (s);
 313   TRACE ("%s\n", __PRETTY_FUNCTION__);
 314   MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strdup region");
 315   result = (char *)CALL_REAL(malloc,
 316                              CLAMPADD(CLAMPADD(n,1),
 317                                       CLAMPADD(__mf_opts.crumple_zone,
 318                                                __mf_opts.crumple_zone)));
 319
 320   if (UNLIKELY(! result)) return result;
 321
 322   result += __mf_opts.crumple_zone;
 323   memcpy (result, s, n);
 324   result[n] = '\0';
 325
 326   __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strdup region");
 327   return result;
 328 }
 329
 330
 331 WRAPPER2(char *, strndup, const char *s, size_t n)
 332 {
 333   DECLARE(void *, malloc, size_t sz);
 334   char *result;
 335   size_t sz = strnlen (s, n);
 336   TRACE ("%s\n", __PRETTY_FUNCTION__);
 337   MF_VALIDATE_EXTENT(s, sz, __MF_CHECK_READ, "strndup region"); /* nb: strNdup */
 338
 339   /* note: strndup still adds a \0, even with the N limit! */
 340   result = (char *)CALL_REAL(malloc,
 341                              CLAMPADD(CLAMPADD(n,1),
 342                                       CLAMPADD(__mf_opts.crumple_zone,
 343                                                __mf_opts.crumple_zone)));
 344
 345   if (UNLIKELY(! result)) return result;
 346
 347   result += __mf_opts.crumple_zone;
 348   memcpy (result, s, n);
 349   result[n] = '\0';
 350
 351   __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strndup region");
 352   return result;
 353 }
 354
 355
 356 WRAPPER2(char *, strchr, const char *s, int c)
 357 {
 358   size_t n;
 359   TRACE ("%s\n", __PRETTY_FUNCTION__);
 360   n = strlen (s);
 361   MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strchr region");
 362   return strchr (s, c);
 363 }
 364
 365
 366 WRAPPER2(char *, strrchr, const char *s, int c)
 367 {
 368   size_t n;
 369   TRACE ("%s\n", __PRETTY_FUNCTION__);
 370   n = strlen (s);
 371   MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strrchr region");
 372   return strrchr (s, c);
 373 }
 374
 375
 376 WRAPPER2(char *, strstr, const char *haystack, const char *needle)
 377 {
 378   size_t haystack_sz;
 379   size_t needle_sz;
 380   TRACE ("%s\n", __PRETTY_FUNCTION__);
 381   haystack_sz = strlen (haystack);
 382   needle_sz = strlen (needle);
 383   MF_VALIDATE_EXTENT(haystack, CLAMPADD(haystack_sz, 1), __MF_CHECK_READ, "strstr haystack");
 384   MF_VALIDATE_EXTENT(needle, CLAMPADD(needle_sz, 1), __MF_CHECK_READ, "strstr needle");
 385   return strstr (haystack, needle);
 386 }
 387
 388
 389 #ifdef HAVE_MEMMEM
 390 WRAPPER2(void *, memmem,
 391         const void *haystack, size_t haystacklen,
 392         const void *needle, size_t needlelen)
 393 {
 394   TRACE ("%s\n", __PRETTY_FUNCTION__);
 395   MF_VALIDATE_EXTENT(haystack, haystacklen, __MF_CHECK_READ, "memmem haystack");
 396   MF_VALIDATE_EXTENT(needle, needlelen, __MF_CHECK_READ, "memmem needle");
 397   return memmem (haystack, haystacklen, needle, needlelen);
 398 }
 399 #endif
 400
 401
 402 WRAPPER2(size_t, strlen, const char *s)
 403 {
 404   size_t result = strlen (s);
 405   TRACE ("%s\n", __PRETTY_FUNCTION__);
 406   MF_VALIDATE_EXTENT(s, CLAMPADD(result, 1), __MF_CHECK_READ, "strlen region");
 407   return result;
 408 }
 409
 410
 411 WRAPPER2(size_t, strnlen, const char *s, size_t n)
 412 {
 413   size_t result = strnlen (s, n);
 414   TRACE ("%s\n", __PRETTY_FUNCTION__);
 415   MF_VALIDATE_EXTENT(s, result, __MF_CHECK_READ, "strnlen region");
 416   return result;
 417 }
 418
 419
 420 WRAPPER2(void, bzero, void *s, size_t n)
 421 {
 422   TRACE ("%s\n", __PRETTY_FUNCTION__);
 423   MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "bzero region");
 424   bzero (s, n);
 425 }
 426
 427
 428 #undef bcopy
 429 WRAPPER2(void, bcopy, const void *src, void *dest, size_t n)
 430 {
 431   TRACE ("%s\n", __PRETTY_FUNCTION__);
 432   MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "bcopy src");
 433   MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "bcopy dest");
 434   bcopy (src, dest, n);
 435 }
 436
 437
 438 #undef bcmp
 439 WRAPPER2(int, bcmp, const void *s1, const void *s2, size_t n)
 440 {
 441   TRACE ("%s\n", __PRETTY_FUNCTION__);
 442   MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "bcmp 1st arg");
 443   MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "bcmp 2nd arg");
 444   return bcmp (s1, s2, n);
 445 }
 446
 447
 448 WRAPPER2(char *, index, const char *s, int c)
 449 {
 450   size_t n = strlen (s);
 451   TRACE ("%s\n", __PRETTY_FUNCTION__);
 452   MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "index region");
 453   return index (s, c);
 454 }
 455
 456
 457 WRAPPER2(char *, rindex, const char *s, int c)
 458 {
 459   size_t n = strlen (s);
 460   TRACE ("%s\n", __PRETTY_FUNCTION__);
 461   MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "rindex region");
 462   return rindex (s, c);
 463 }
 464
 465 /* XXX:  stpcpy, memccpy */
 466
 467 /* XXX: *printf,*scanf */
 468
 469 /* XXX: setjmp, longjmp */
 470
 471 WRAPPER2(char *, asctime, struct tm *tm)
 472 {
 473   static char *reg_result = NULL;
 474   char *result;
 475   TRACE ("%s\n", __PRETTY_FUNCTION__);
 476   MF_VALIDATE_EXTENT(tm, sizeof (struct tm), __MF_CHECK_READ, "asctime tm");
 477   result = asctime (tm);
 478   if (reg_result == NULL)
 479     {
 480       __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "asctime string");
 481       reg_result = result;
 482     }
 483   return result;
 484 }
 485
 486
 487 WRAPPER2(char *, ctime, const time_t *timep)
 488 {
 489   static char *reg_result = NULL;
 490   char *result;
 491   TRACE ("%s\n", __PRETTY_FUNCTION__);
 492   MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "ctime time");
 493   result = ctime (timep);
 494   if (reg_result == NULL)
 495     {
 496       /* XXX: what if asctime and ctime return the same static ptr? */
 497       __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "ctime string");
 498       reg_result = result;
 499     }
 500   return result;
 501 }
 502
 503
 504 WRAPPER2(struct tm*, localtime, const time_t *timep)
 505 {
 506   static struct tm *reg_result = NULL;
 507   struct tm *result;
 508   TRACE ("%s\n", __PRETTY_FUNCTION__);
 509   MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "localtime time");
 510   result = localtime (timep);
 511   if (reg_result == NULL)
 512     {
 513       __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "localtime tm");
 514       reg_result = result;
 515     }
 516   return result;
 517 }
 518
 519
 520 WRAPPER2(struct tm*, gmtime, const time_t *timep)
 521 {
 522   static struct tm *reg_result = NULL;
 523   struct tm *result;
 524   TRACE ("%s\n", __PRETTY_FUNCTION__);
 525   MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "gmtime time");
 526   result = gmtime (timep);
 527   if (reg_result == NULL)
 528     {
 529       __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "gmtime tm");
 530       reg_result = result;
 531     }
 532   return result;
 533 }
 534
 535
 536 /* EL start */
 537
 538 /* The following indicate if the result of the corresponding function
 539  * should be explicitly un/registered by the wrapper
 540 */
 541
 542 #ifdef __FreeBSD__
 543 #define MF_REGISTER_fopen               __MF_TYPE_STATIC
 544 #else
 545 #undef  MF_REGISTER_fopen
 546 #endif
 547 #define MF_RESULT_SIZE_fopen            (sizeof (FILE))
 548
 549 #undef  MF_REGISTER_opendir
 550 #define MF_RESULT_SIZE_opendir          0       /* (sizeof (DIR)) */
 551 #undef  MF_REGISTER_readdir
 552 #define MF_REGISTER_gethostbyname       __MF_TYPE_STATIC
 553 #undef  MF_REGISTER_gethostbyname_items
 554 #undef  MF_REGISTER_dlopen
 555 #undef  MF_REGISTER_dlerror
 556 #undef  MF_REGISTER_dlsym
 557 #define MF_REGISTER_shmat               __MF_TYPE_GUESS
 558
 559
 560 #include <time.h>
 561 WRAPPER2(time_t, time, time_t *timep)
 562 {
 563   TRACE ("%s\n", __PRETTY_FUNCTION__);
 564   if (NULL != timep)
 565     MF_VALIDATE_EXTENT (timep, sizeof (*timep), __MF_CHECK_WRITE,
 566       "time timep");
 567   return time (timep);
 568 }
 569
 570
 571 WRAPPER2(char *, strerror, int errnum)
 572 {
 573   char *p;
 574   static char * last_strerror = NULL;
 575
 576   TRACE ("%s\n", __PRETTY_FUNCTION__);
 577   p = strerror (errnum);
 578   if (last_strerror != NULL)
 579     __mf_unregister (last_strerror, 0, __MF_TYPE_STATIC);
 580   if (NULL != p)
 581     __mf_register (p, strlen (p) + 1, __MF_TYPE_STATIC, "strerror result");
 582   last_strerror = p;
 583   return p;
 584 }
 585
 586
 587
 588 /* An auxiliary data structure for tracking the hand-made stdio
 589    buffers we generate during the fopen/fopen64 hooks.  In a civilized
 590    language, this would be a simple dynamically sized FILE*->char*
 591    lookup table, but this is C and we get to do it by hand.  */
 592 struct mf_filebuffer
 593 {
 594   FILE *file;
 595   char *buffer;
 596   struct mf_filebuffer *next;
 597 };
 598 static struct mf_filebuffer *mf_filebuffers = NULL;
 599
 600 static void
 601 mkbuffer (FILE *f)
 602 {
 603   /* Reset any buffer automatically provided by libc, since this may
 604      have been done via mechanisms that libmudflap couldn't
 605      intercept.  */
 606   int rc;
 607   size_t bufsize = BUFSIZ;
 608   int bufmode;
 609   char *buffer = malloc (bufsize);
 610   struct mf_filebuffer *b = malloc (sizeof (struct mf_filebuffer));
 611   assert ((buffer != NULL) && (b != NULL));
 612
 613   /* Link it into list.  */
 614   b->file = f;
 615   b->buffer = buffer;
 616   b->next = mf_filebuffers;
 617   mf_filebuffers = b;
 618
 619   /* Determine how the file is supposed to be buffered at the moment.  */
 620   bufmode = fileno (f) == 2 ? _IONBF : (isatty (fileno (f)) ? _IOLBF : _IOFBF);
 621
 622   rc = setvbuf (f, buffer, bufmode, bufsize);
 623   assert (rc == 0);
 624 }
 625
 626 static void
 627 unmkbuffer (FILE *f)
 628 {
 629   struct mf_filebuffer *b = mf_filebuffers;
 630   struct mf_filebuffer **pb = & mf_filebuffers;
 631   while (b != NULL)
 632     {
 633       if (b->file == f)
 634         {
 635           *pb = b->next;
 636           free (b->buffer);
 637           free (b);
 638           return;
 639         }
 640       pb = & b->next;
 641       b = b->next;
 642     }
 643 }
 644
 645
 646
 647 WRAPPER2(FILE *, fopen, const char *path, const char *mode)
 648 {
 649   size_t n;
 650   FILE *p;
 651   TRACE ("%s\n", __PRETTY_FUNCTION__);
 652
 653   n = strlen (path);
 654   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen path");
 655
 656   n = strlen (mode);
 657   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen mode");
 658
 659   p = fopen (path, mode);
 660   if (NULL != p) {
 661 #ifdef MF_REGISTER_fopen
 662     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen result");
 663 #endif
 664     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen result");
 665
 666     mkbuffer (p);
 667   }
 668
 669   return p;
 670 }
 671
 672
 673 WRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode, size_t size)
 674 {
 675   int rc = 0;
 676   TRACE ("%s\n", __PRETTY_FUNCTION__);
 677
 678   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, "setvbuf stream");
 679
 680   unmkbuffer (stream);
 681
 682   if (buf != NULL)
 683     MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_WRITE, "setvbuf buffer");
 684
 685   /* Override the user only if it's an auto-allocated buffer request.  Otherwise
 686      assume that the supplied buffer is already known to libmudflap.  */
 687   if ((buf == NULL) && ((mode == _IOFBF) || (mode == _IOLBF)))
 688     mkbuffer (stream);
 689   else
 690     rc = setvbuf (stream, buf, mode, size);
 691
 692   return rc;
 693 }
 694
 695
 696 #ifdef HAVE_SETBUF
 697 WRAPPER2(int, setbuf, FILE* stream, char *buf)
 698 {
 699   return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
 700 }
 701 #endif
 702
 703 #ifdef HAVE_SETBUFFER
 704 WRAPPER2(int, setbuffer, FILE* stream, char *buf, size_t sz)
 705 {
 706   return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, sz);
 707 }
 708 #endif
 709
 710 #ifdef HAVE_SETLINEBUF
 711 WRAPPER2(int, setlinebuf, FILE* stream)
 712 {
 713   return __mfwrap_setvbuf(stream, NULL, _IOLBF, 0);
 714 }
 715 #endif
 716
 717
 718
 719 WRAPPER2(FILE *, fdopen, int fd, const char *mode)
 720 {
 721   size_t n;
 722   FILE *p;
 723   TRACE ("%s\n", __PRETTY_FUNCTION__);
 724
 725   n = strlen (mode);
 726   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fdopen mode");
 727
 728   p = fdopen (fd, mode);
 729   if (NULL != p) {
 730 #ifdef MF_REGISTER_fopen
 731     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fdopen result");
 732 #endif
 733     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fdopen result");
 734
 735     mkbuffer (p);
 736   }
 737
 738   return p;
 739 }
 740
 741
 742 WRAPPER2(FILE *, freopen, const char *path, const char *mode, FILE *s)
 743 {
 744   size_t n;
 745   FILE *p;
 746   TRACE ("%s\n", __PRETTY_FUNCTION__);
 747
 748   n = strlen (path);
 749   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen path");
 750
 751   MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen stream");
 752   unmkbuffer (s);
 753
 754   n = strlen (mode);
 755   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen mode");
 756
 757   p = freopen (path, mode, s);
 758   if (NULL != p) {
 759 #ifdef MF_REGISTER_fopen
 760     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen result");
 761 #endif
 762     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen result");
 763
 764     mkbuffer (p);
 765   }
 766
 767   return p;
 768 }
 769
 770
 771 #ifdef HAVE_FOPEN64
 772 WRAPPER2(FILE *, fopen64, const char *path, const char *mode)
 773 {
 774   size_t n;
 775   FILE *p;
 776   TRACE ("%s\n", __PRETTY_FUNCTION__);
 777
 778   n = strlen (path);
 779   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 path");
 780
 781   n = strlen (mode);
 782   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 mode");
 783
 784   p = fopen64 (path, mode);
 785   if (NULL != p) {
 786 #ifdef MF_REGISTER_fopen
 787     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen64 result");
 788 #endif
 789     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen64 result");
 790
 791     mkbuffer (p);
 792   }
 793
 794   return p;
 795 }
 796 #endif
 797
 798
 799 #ifdef HAVE_FREOPEN64
 800 WRAPPER2(FILE *, freopen64, const char *path, const char *mode, FILE *s)
 801 {
 802   size_t n;
 803   FILE *p;
 804   TRACE ("%s\n", __PRETTY_FUNCTION__);
 805
 806   n = strlen (path);
 807   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 path");
 808
 809   MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen64 stream");
 810   unmkbuffer (s);
 811
 812   n = strlen (mode);
 813   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 mode");
 814
 815   p = freopen (path, mode, s);
 816   if (NULL != p) {
 817 #ifdef MF_REGISTER_fopen
 818     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen64 result");
 819 #endif
 820     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen64 result");
 821
 822     mkbuffer (p);
 823   }
 824
 825   return p;
 826 }
 827 #endif
 828
 829
 830 WRAPPER2(int, fclose, FILE *stream)
 831 {
 832   int resp;
 833   TRACE ("%s\n", __PRETTY_FUNCTION__);
 834   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 835     "fclose stream");
 836   resp = fclose (stream);
 837 #ifdef MF_REGISTER_fopen
 838   __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
 839 #endif
 840   unmkbuffer (stream);
 841
 842   return resp;
 843 }
 844
 845
 846 WRAPPER2(size_t, fread, void *ptr, size_t size, size_t nmemb, FILE *stream)
 847 {
 848   TRACE ("%s\n", __PRETTY_FUNCTION__);
 849   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 850     "fread stream");
 851   MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_WRITE, "fread buffer");
 852   return fread (ptr, size, nmemb, stream);
 853 }
 854
 855
 856 WRAPPER2(size_t, fwrite, const void *ptr, size_t size, size_t nmemb,
 857         FILE *stream)
 858 {
 859   TRACE ("%s\n", __PRETTY_FUNCTION__);
 860   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 861     "fwrite stream");
 862   MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_READ, "fwrite buffer");
 863   return fwrite (ptr, size, nmemb, stream);
 864 }
 865
 866
 867 WRAPPER2(int, fgetc, FILE *stream)
 868 {
 869   TRACE ("%s\n", __PRETTY_FUNCTION__);
 870   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 871     "fgetc stream");
 872   return fgetc (stream);
 873 }
 874
 875
 876 WRAPPER2(char *, fgets, char *s, int size, FILE *stream)
 877 {
 878   TRACE ("%s\n", __PRETTY_FUNCTION__);
 879   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 880     "fgets stream");
 881   MF_VALIDATE_EXTENT (s, size, __MF_CHECK_WRITE, "fgets buffer");
 882   return fgets (s, size, stream);
 883 }
 884
 885
 886 WRAPPER2(int, getc, FILE *stream)
 887 {
 888   TRACE ("%s\n", __PRETTY_FUNCTION__);
 889   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 890     "getc stream");
 891   return getc (stream);
 892 }
 893
 894
 895 WRAPPER2(char *, gets, char *s)
 896 {
 897   TRACE ("%s\n", __PRETTY_FUNCTION__);
 898   MF_VALIDATE_EXTENT (s, 1, __MF_CHECK_WRITE, "gets buffer");
 899   /* Avoid link-time warning... */
 900   s = fgets (s, INT_MAX, stdin);
 901   if (NULL != s) {      /* better late than never */
 902     size_t n = strlen (s);
 903     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_WRITE, "gets buffer");
 904   }
 905   return s;
 906 }
 907
 908
 909 WRAPPER2(int, ungetc, int c, FILE *stream)
 910 {
 911   TRACE ("%s\n", __PRETTY_FUNCTION__);
 912   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 913      "ungetc stream");
 914   return ungetc (c, stream);
 915 }
 916
 917
 918 WRAPPER2(int, fputc, int c, FILE *stream)
 919 {
 920   TRACE ("%s\n", __PRETTY_FUNCTION__);
 921   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 922     "fputc stream");
 923   return fputc (c, stream);
 924 }
 925
 926
 927 WRAPPER2(int, fputs, const char *s, FILE *stream)
 928 {
 929   size_t n;
 930   TRACE ("%s\n", __PRETTY_FUNCTION__);
 931   n = strlen (s);
 932   MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "fputs buffer");
 933   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 934     "fputs stream");
 935   return fputs (s, stream);
 936 }
 937
 938
 939 WRAPPER2(int, putc, int c, FILE *stream)
 940 {
 941   TRACE ("%s\n", __PRETTY_FUNCTION__);
 942   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 943     "putc stream");
 944   return putc (c, stream);
 945 }
 946
 947
 948 WRAPPER2(int, puts, const char *s)
 949 {
 950   size_t n;
 951   TRACE ("%s\n", __PRETTY_FUNCTION__);
 952   n = strlen (s);
 953   MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "puts buffer");
 954   return puts (s);
 955 }
 956
 957
 958 WRAPPER2(void, clearerr, FILE *stream)
 959 {
 960   TRACE ("%s\n", __PRETTY_FUNCTION__);
 961   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 962     "clearerr stream");
 963   clearerr (stream);
 964 }
 965
 966
 967 WRAPPER2(int, feof, FILE *stream)
 968 {
 969   TRACE ("%s\n", __PRETTY_FUNCTION__);
 970   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 971     "feof stream");
 972   return feof (stream);
 973 }
 974
 975
 976 WRAPPER2(int, ferror, FILE *stream)
 977 {
 978   TRACE ("%s\n", __PRETTY_FUNCTION__);
 979   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 980     "ferror stream");
 981   return ferror (stream);
 982 }
 983
 984
 985 WRAPPER2(int, fileno, FILE *stream)
 986 {
 987   TRACE ("%s\n", __PRETTY_FUNCTION__);
 988   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
 989     "fileno stream");
 990   return fileno (stream);
 991 }
 992
 993
 994 WRAPPER2(int, printf, const char *format, ...)
 995 {
 996   size_t n;
 997   va_list ap;
 998   int result;
 999   TRACE ("%s\n", __PRETTY_FUNCTION__);
1000   n = strlen (format);
1001   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1002     "printf format");
1003   va_start (ap, format);
1004   result = vprintf (format, ap);
1005   va_end (ap);
1006   return result;
1007 }
1008
1009
1010 WRAPPER2(int, fprintf, FILE *stream, const char *format, ...)
1011 {
1012   size_t n;
1013   va_list ap;
1014   int result;
1015   TRACE ("%s\n", __PRETTY_FUNCTION__);
1016   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1017     "fprintf stream");
1018   n = strlen (format);
1019   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1020     "fprintf format");
1021   va_start (ap, format);
1022   result = vfprintf (stream, format, ap);
1023   va_end (ap);
1024   return result;
1025 }
1026
1027
1028 WRAPPER2(int, sprintf, char *str, const char *format, ...)
1029 {
1030   size_t n;
1031   va_list ap;
1032   int result;
1033   TRACE ("%s\n", __PRETTY_FUNCTION__);
1034   MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "sprintf str");
1035   n = strlen (format);
1036   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1037     "sprintf format");
1038   va_start (ap, format);
1039   result = vsprintf (str, format, ap);
1040   va_end (ap);
1041   n = strlen (str);
1042   MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "sprintf str");
1043   return result;
1044 }
1045
1046
1047 WRAPPER2(int, snprintf, char *str, size_t size, const char *format, ...)
1048 {
1049   size_t n;
1050   va_list ap;
1051   int result;
1052   TRACE ("%s\n", __PRETTY_FUNCTION__);
1053   MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "snprintf str");
1054   n = strlen (format);
1055   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1056     "snprintf format");
1057   va_start (ap, format);
1058   result = vsnprintf (str, size, format, ap);
1059   va_end (ap);
1060   return result;
1061 }
1062
1063
1064 WRAPPER2(int, vprintf,  const char *format, va_list ap)
1065 {
1066   size_t n;
1067   TRACE ("%s\n", __PRETTY_FUNCTION__);
1068   n = strlen (format);
1069   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1070     "vprintf format");
1071   return vprintf (format, ap);
1072 }
1073
1074
1075 WRAPPER2(int, vfprintf, FILE *stream, const char *format, va_list ap)
1076 {
1077   size_t n;
1078   TRACE ("%s\n", __PRETTY_FUNCTION__);
1079   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1080     "vfprintf stream");
1081   n = strlen (format);
1082   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1083     "vfprintf format");
1084   return vfprintf (stream, format, ap);
1085 }
1086
1087
1088 WRAPPER2(int, vsprintf, char *str, const char *format, va_list ap)
1089 {
1090   size_t n;
1091   int result;
1092   TRACE ("%s\n", __PRETTY_FUNCTION__);
1093   MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "vsprintf str");
1094   n = strlen (format);
1095   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1096     "vsprintf format");
1097   result = vsprintf (str, format, ap);
1098   n = strlen (str);
1099   MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "vsprintf str");
1100   return result;
1101 }
1102
1103
1104 WRAPPER2(int, vsnprintf, char *str, size_t size, const char *format,
1105         va_list ap)
1106 {
1107   size_t n;
1108   TRACE ("%s\n", __PRETTY_FUNCTION__);
1109   MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "vsnprintf str");
1110   n = strlen (format);
1111   MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
1112     "vsnprintf format");
1113   return vsnprintf (str, size, format, ap);
1114 }
1115
1116
1117 WRAPPER2(int , access, const char *path, int mode)
1118 {
1119   size_t n;
1120   TRACE ("%s\n", __PRETTY_FUNCTION__);
1121   n = strlen (path);
1122   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "access path");
1123   return access (path, mode);
1124 }
1125
1126
1127 WRAPPER2(int , remove, const char *path)
1128 {
1129   size_t n;
1130   TRACE ("%s\n", __PRETTY_FUNCTION__);
1131   n = strlen (path);
1132   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "remove path");
1133   return remove (path);
1134 }
1135
1136
1137 WRAPPER2(int, fflush, FILE *stream)
1138 {
1139   TRACE ("%s\n", __PRETTY_FUNCTION__);
1140   if (stream != NULL)
1141     MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1142                         "fflush stream");
1143   return fflush (stream);
1144 }
1145
1146
1147 WRAPPER2(int, fseek, FILE *stream, long offset, int whence)
1148 {
1149   TRACE ("%s\n", __PRETTY_FUNCTION__);
1150   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1151     "fseek stream");
1152   return fseek (stream, offset, whence);
1153 }
1154
1155
1156 #ifdef HAVE_FSEEKO64
1157 WRAPPER2(int, fseeko64, FILE *stream, off64_t offset, int whence)
1158 {
1159   TRACE ("%s\n", __PRETTY_FUNCTION__);
1160   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1161     "fseeko64 stream");
1162   return fseeko64 (stream, offset, whence);
1163 }
1164 #endif
1165
1166
1167 WRAPPER2(long, ftell, FILE *stream)
1168 {
1169   TRACE ("%s\n", __PRETTY_FUNCTION__);
1170   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1171     "ftell stream");
1172   return ftell (stream);
1173 }
1174
1175
1176 #ifdef HAVE_FTELLO64
1177 WRAPPER2(off64_t, ftello64, FILE *stream)
1178 {
1179   TRACE ("%s\n", __PRETTY_FUNCTION__);
1180   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1181     "ftello64 stream");
1182   return ftello64 (stream);
1183 }
1184 #endif
1185
1186
1187 WRAPPER2(void, rewind, FILE *stream)
1188 {
1189   TRACE ("%s\n", __PRETTY_FUNCTION__);
1190   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1191     "rewind stream");
1192   rewind (stream);
1193 }
1194
1195
1196 WRAPPER2(int, fgetpos, FILE *stream, fpos_t *pos)
1197 {
1198   TRACE ("%s\n", __PRETTY_FUNCTION__);
1199   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1200     "fgetpos stream");
1201   MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_WRITE, "fgetpos pos");
1202   return fgetpos (stream, pos);
1203 }
1204
1205
1206 WRAPPER2(int, fsetpos, FILE *stream, fpos_t *pos)
1207 {
1208   TRACE ("%s\n", __PRETTY_FUNCTION__);
1209   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1210     "fsetpos stream");
1211   MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_READ, "fsetpos pos");
1212   return fsetpos (stream, pos);
1213 }
1214
1215
1216 WRAPPER2(int , stat, const char *path, struct stat *buf)
1217 {
1218   size_t n;
1219   TRACE ("%s\n", __PRETTY_FUNCTION__);
1220   n = strlen (path);
1221   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat path");
1222   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat buf");
1223   return stat (path, buf);
1224 }
1225
1226
1227 #ifdef HAVE_STAT64
1228 WRAPPER2(int , stat64, const char *path, struct stat64 *buf)
1229 {
1230   size_t n;
1231   TRACE ("%s\n", __PRETTY_FUNCTION__);
1232   n = strlen (path);
1233   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat64 path");
1234   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat64 buf");
1235   return stat64 (path, buf);
1236 }
1237 #endif
1238
1239
1240 WRAPPER2(int , fstat, int filedes, struct stat *buf)
1241 {
1242   TRACE ("%s\n", __PRETTY_FUNCTION__);
1243   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "fstat buf");
1244   return fstat (filedes, buf);
1245 }
1246
1247
1248 WRAPPER2(int , lstat, const char *path, struct stat *buf)
1249 {
1250   size_t n;
1251   TRACE ("%s\n", __PRETTY_FUNCTION__);
1252   n = strlen (path);
1253   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "lstat path");
1254   MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "lstat buf");
1255   return lstat (path, buf);
1256 }
1257
1258
1259 WRAPPER2(int , mkfifo, const char *path, mode_t mode)
1260 {
1261   size_t n;
1262   TRACE ("%s\n", __PRETTY_FUNCTION__);
1263   n = strlen (path);
1264   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "mkfifo path");
1265   return mkfifo (path, mode);
1266 }
1267
1268
1269 #ifdef HAVE_DIRENT_H
1270 WRAPPER2(DIR *, opendir, const char *path)
1271 {
1272   DIR *p;
1273   size_t n;
1274   TRACE ("%s\n", __PRETTY_FUNCTION__);
1275   n = strlen (path);
1276   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "opendir path");
1277
1278   p = opendir (path);
1279   if (NULL != p) {
1280 #ifdef MF_REGISTER_opendir
1281     __mf_register (p, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir,
1282       "opendir result");
1283 #endif
1284     MF_VALIDATE_EXTENT (p, MF_RESULT_SIZE_opendir, __MF_CHECK_WRITE,
1285       "opendir result");
1286   }
1287   return p;
1288 }
1289
1290
1291 WRAPPER2(int, closedir, DIR *dir)
1292 {
1293   TRACE ("%s\n", __PRETTY_FUNCTION__);
1294   MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_WRITE, "closedir dir");
1295 #ifdef MF_REGISTER_opendir
1296   __mf_unregister (dir, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir);
1297 #endif
1298   return closedir (dir);
1299 }
1300
1301
1302 WRAPPER2(struct dirent *, readdir, DIR *dir)
1303 {
1304   struct dirent *p;
1305   TRACE ("%s\n", __PRETTY_FUNCTION__);
1306   MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_READ, "readdir dir");
1307   p = readdir (dir);
1308   if (NULL != p) {
1309 #ifdef MF_REGISTER_readdir
1310     __mf_register (p, sizeof (*p), MF_REGISTER_readdir, "readdir result");
1311 #endif
1312     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "readdir result");
1313   }
1314   return p;
1315 }
1316 #endif
1317
1318
1319 #ifdef HAVE_SYS_SOCKET_H
1320
1321 WRAPPER2(int, recv, int s, void *buf, size_t len, int flags)
1322 {
1323   TRACE ("%s\n", __PRETTY_FUNCTION__);
1324   MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recv buf");
1325   return recv (s, buf, len, flags);
1326 }
1327
1328
1329 WRAPPER2(int, recvfrom, int s, void *buf, size_t len, int flags,
1330                 struct sockaddr *from, socklen_t *fromlen)
1331 {
1332   TRACE ("%s\n", __PRETTY_FUNCTION__);
1333   MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recvfrom buf");
1334   MF_VALIDATE_EXTENT (from, (size_t)*fromlen, __MF_CHECK_WRITE,
1335     "recvfrom from");
1336   return recvfrom (s, buf, len, flags, from, fromlen);
1337 }
1338
1339
1340 WRAPPER2(int, recvmsg, int s, struct msghdr *msg, int flags)
1341 {
1342   TRACE ("%s\n", __PRETTY_FUNCTION__);
1343   MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_WRITE, "recvmsg msg");
1344   return recvmsg (s, msg, flags);
1345 }
1346
1347
1348 WRAPPER2(int, send, int s, const void *msg, size_t len, int flags)
1349 {
1350   TRACE ("%s\n", __PRETTY_FUNCTION__);
1351   MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "send msg");
1352   return send (s, msg, len, flags);
1353 }
1354
1355
1356 WRAPPER2(int, sendto, int s, const void *msg, size_t len, int flags,
1357                 const struct sockaddr *to, socklen_t tolen)
1358 {
1359   TRACE ("%s\n", __PRETTY_FUNCTION__);
1360   MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "sendto msg");
1361   MF_VALIDATE_EXTENT (to, (size_t)tolen, __MF_CHECK_WRITE, "sendto to");
1362   return sendto (s, msg, len, flags, to, tolen);
1363 }
1364
1365
1366 WRAPPER2(int, sendmsg, int s, const void *msg, int flags)
1367 {
1368   TRACE ("%s\n", __PRETTY_FUNCTION__);
1369   MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_READ, "sendmsg msg");
1370   return sendmsg (s, msg, flags);
1371 }
1372
1373
1374 WRAPPER2(int, setsockopt, int s, int level, int optname, const void *optval,
1375         socklen_t optlen)
1376 {
1377   TRACE ("%s\n", __PRETTY_FUNCTION__);
1378   MF_VALIDATE_EXTENT (optval, (size_t)optlen, __MF_CHECK_READ,
1379     "setsockopt optval");
1380   return setsockopt (s, level, optname, optval, optlen);
1381 }
1382
1383
1384 WRAPPER2(int, getsockopt, int s, int level, int optname, void *optval,
1385                 socklen_t *optlen)
1386 {
1387   TRACE ("%s\n", __PRETTY_FUNCTION__);
1388   MF_VALIDATE_EXTENT (optval, (size_t)*optlen, __MF_CHECK_WRITE,
1389     "getsockopt optval");
1390   return getsockopt (s, level, optname, optval, optlen);
1391 }
1392
1393
1394 WRAPPER2(int, accept, int s, struct  sockaddr *addr, socklen_t *addrlen)
1395 {
1396   TRACE ("%s\n", __PRETTY_FUNCTION__);
1397   if (addr != NULL)
1398     MF_VALIDATE_EXTENT (addr, (size_t)*addrlen, __MF_CHECK_WRITE, "accept addr");
1399   return accept (s, addr, addrlen);
1400 }
1401
1402
1403 WRAPPER2(int, bind, int sockfd, struct  sockaddr *addr, socklen_t addrlen)
1404 {
1405   TRACE ("%s\n", __PRETTY_FUNCTION__);
1406   MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_WRITE, "bind addr");
1407   return bind (sockfd, addr, addrlen);
1408 }
1409
1410
1411 WRAPPER2(int, connect, int sockfd, const struct sockaddr  *addr,
1412         socklen_t addrlen)
1413 {
1414   TRACE ("%s\n", __PRETTY_FUNCTION__);
1415   MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_READ,
1416     "connect addr");
1417   return connect (sockfd, addr, addrlen);
1418 }
1419
1420 #endif /* HAVE_SYS_SOCKET_H */
1421
1422
1423 WRAPPER2(int, gethostname, char *name, size_t len)
1424 {
1425   TRACE ("%s\n", __PRETTY_FUNCTION__);
1426   MF_VALIDATE_EXTENT (name, len, __MF_CHECK_WRITE, "gethostname name");
1427   return gethostname (name, len);
1428 }
1429
1430
1431 #ifdef HAVE_SETHOSTNAME
1432 WRAPPER2(int, sethostname, const char *name, size_t len)
1433 {
1434   TRACE ("%s\n", __PRETTY_FUNCTION__);
1435   MF_VALIDATE_EXTENT (name, len, __MF_CHECK_READ, "sethostname name");
1436   return sethostname (name, len);
1437 }
1438 #endif
1439
1440
1441 #ifdef HAVE_NETDB_H
1442
1443 WRAPPER2(struct hostent *, gethostbyname, const char *name)
1444 {
1445   struct hostent *p;
1446   char **ss;
1447   char *s;
1448   size_t n;
1449   int nreg;
1450   TRACE ("%s\n", __PRETTY_FUNCTION__);
1451   n = strlen (name);
1452   MF_VALIDATE_EXTENT (name, CLAMPADD(n, 1), __MF_CHECK_READ,
1453     "gethostbyname name");
1454   p = gethostbyname (name);
1455   if (NULL != p) {
1456 #ifdef MF_REGISTER_gethostbyname
1457     __mf_register (p, sizeof (*p), MF_REGISTER_gethostbyname,
1458       "gethostbyname result");
1459 #endif
1460     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE,
1461       "gethostbyname result");
1462     if (NULL != (s = p->h_name)) {
1463       n = strlen (s);
1464       n = CLAMPADD(n, 1);
1465 #ifdef MF_REGISTER_gethostbyname_items
1466       __mf_register (s, n, MF_REGISTER_gethostbyname_items,
1467         "gethostbyname result->h_name");
1468 #endif
1469       MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE,
1470         "gethostbyname result->h_name");
1471     }
1472
1473     if (NULL != (ss = p->h_aliases)) {
1474       for (nreg = 1;; ++nreg) {
1475         s = *ss++;
1476         if (NULL == s)
1477           break;
1478         n = strlen (s);
1479         n = CLAMPADD(n, 1);
1480 #ifdef MF_REGISTER_gethostbyname_items
1481         __mf_register (s, n, MF_REGISTER_gethostbyname_items,
1482           "gethostbyname result->h_aliases[]");
1483 #endif
1484         MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE,
1485           "gethostbyname result->h_aliases[]");
1486       }
1487       nreg *= sizeof (*p->h_aliases);
1488 #ifdef MF_REGISTER_gethostbyname_items
1489       __mf_register (p->h_aliases, nreg, MF_REGISTER_gethostbyname_items,
1490         "gethostbyname result->h_aliases");
1491 #endif
1492       MF_VALIDATE_EXTENT (p->h_aliases, nreg, __MF_CHECK_WRITE,
1493         "gethostbyname result->h_aliases");
1494     }
1495
1496     if (NULL != (ss = p->h_addr_list)) {
1497       for (nreg = 1;; ++nreg) {
1498         s = *ss++;
1499         if (NULL == s)
1500           break;
1501 #ifdef MF_REGISTER_gethostbyname_items
1502         __mf_register (s, p->h_length, MF_REGISTER_gethostbyname_items,
1503           "gethostbyname result->h_addr_list[]");
1504 #endif
1505         MF_VALIDATE_EXTENT (s, p->h_length, __MF_CHECK_WRITE,
1506           "gethostbyname result->h_addr_list[]");
1507       }
1508       nreg *= sizeof (*p->h_addr_list);
1509 #ifdef MF_REGISTER_gethostbyname_items
1510       __mf_register (p->h_addr_list, nreg, MF_REGISTER_gethostbyname_items,
1511         "gethostbyname result->h_addr_list");
1512 #endif
1513       MF_VALIDATE_EXTENT (p->h_addr_list, nreg, __MF_CHECK_WRITE,
1514         "gethostbyname result->h_addr_list");
1515     }
1516   }
1517   return p;
1518 }
1519
1520 #endif /* HAVE_NETDB_H */
1521
1522
1523 #ifdef HAVE_SYS_WAIT_H
1524
1525 WRAPPER2(pid_t, wait, int *status)
1526 {
1527   TRACE ("%s\n", __PRETTY_FUNCTION__);
1528   if (NULL != status)
1529     MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE,
1530       "wait status");
1531   return wait (status);
1532 }
1533
1534
1535 WRAPPER2(pid_t, waitpid, pid_t pid, int *status, int options)
1536 {
1537   TRACE ("%s\n", __PRETTY_FUNCTION__);
1538   if (NULL != status)
1539     MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE,
1540       "waitpid status");
1541   return waitpid (pid, status, options);
1542 }
1543
1544 #endif /* HAVE_SYS_WAIT_H */
1545
1546
1547 WRAPPER2(FILE *, popen, const char *command, const char *mode)
1548 {
1549   size_t n;
1550   FILE *p;
1551   TRACE ("%s\n", __PRETTY_FUNCTION__);
1552
1553   n = strlen (command);
1554   MF_VALIDATE_EXTENT (command, CLAMPADD(n, 1), __MF_CHECK_READ, "popen path");
1555
1556   n = strlen (mode);
1557   MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "popen mode");
1558
1559   p = popen (command, mode);
1560   if (NULL != p) {
1561 #ifdef MF_REGISTER_fopen
1562     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "popen result");
1563 #endif
1564     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "popen result");
1565   }
1566   return p;
1567 }
1568
1569
1570 WRAPPER2(int, pclose, FILE *stream)
1571 {
1572   int resp;
1573   TRACE ("%s\n", __PRETTY_FUNCTION__);
1574   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
1575     "pclose stream");
1576   resp = pclose (stream);
1577 #ifdef MF_REGISTER_fopen
1578   __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
1579 #endif
1580   return resp;
1581 }
1582
1583
1584 WRAPPER2(int, execve, const char *path, char *const argv [],
1585         char *const envp[])
1586 {
1587   size_t n;
1588   char *const *p;
1589   const char *s;
1590   TRACE ("%s\n", __PRETTY_FUNCTION__);
1591
1592   n = strlen (path);
1593   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execve path");
1594
1595   for (p = argv;;) {
1596     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *argv");
1597     s = *p++;
1598     if (NULL == s)
1599       break;
1600     n = strlen (s);
1601     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **argv");
1602   }
1603
1604   for (p = envp;;) {
1605     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *envp");
1606     s = *p++;
1607     if (NULL == s)
1608       break;
1609     n = strlen (s);
1610     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **envp");
1611   }
1612   return execve (path, argv, envp);
1613 }
1614
1615
1616 WRAPPER2(int, execv, const char *path, char *const argv [])
1617 {
1618   size_t n;
1619   char *const *p;
1620   const char *s;
1621   TRACE ("%s\n", __PRETTY_FUNCTION__);
1622
1623   n = strlen (path);
1624   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execv path");
1625
1626   for (p = argv;;) {
1627     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execv *argv");
1628     s = *p++;
1629     if (NULL == s)
1630       break;
1631     n = strlen (s);
1632     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execv **argv");
1633   }
1634   return execv (path, argv);
1635 }
1636
1637
1638 WRAPPER2(int, execvp, const char *path, char *const argv [])
1639 {
1640   size_t n;
1641   char *const *p;
1642   const char *s;
1643   TRACE ("%s\n", __PRETTY_FUNCTION__);
1644
1645   n = strlen (path);
1646   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp path");
1647
1648   for (p = argv;;) {
1649     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execvp *argv");
1650     s = *p++;
1651     if (NULL == s)
1652       break;
1653     n = strlen (s);
1654     MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp **argv");
1655   }
1656   return execvp (path, argv);
1657 }
1658
1659
1660 WRAPPER2(int, system, const char *string)
1661 {
1662   size_t n;
1663   TRACE ("%s\n", __PRETTY_FUNCTION__);
1664   n = strlen (string);
1665   MF_VALIDATE_EXTENT (string, CLAMPADD(n, 1), __MF_CHECK_READ,
1666     "system string");
1667   return system (string);
1668 }
1669
1670
1671 WRAPPER2(void *, dlopen, const char *path, int flags)
1672 {
1673   void *p;
1674   size_t n;
1675   TRACE ("%s\n", __PRETTY_FUNCTION__);
1676   n = strlen (path);
1677   MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "dlopen path");
1678   p = dlopen (path, flags);
1679   if (NULL != p) {
1680 #ifdef MF_REGISTER_dlopen
1681     __mf_register (p, 0, MF_REGISTER_dlopen, "dlopen result");
1682 #endif
1683     MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlopen result");
1684   }
1685   return p;
1686 }
1687
1688
1689 WRAPPER2(int, dlclose, void *handle)
1690 {
1691   int resp;
1692   TRACE ("%s\n", __PRETTY_FUNCTION__);
1693   MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlclose handle");
1694   resp = dlclose (handle);
1695 #ifdef MF_REGISTER_dlopen
1696   __mf_unregister (handle, 0, MF_REGISTER_dlopen);
1697 #endif
1698   return resp;
1699 }
1700
1701
1702 WRAPPER2(char *, dlerror)
1703 {
1704   char *p;
1705   TRACE ("%s\n", __PRETTY_FUNCTION__);
1706   p = dlerror ();
1707   if (NULL != p) {
1708     size_t n;
1709     n = strlen (p);
1710     n = CLAMPADD(n, 1);
1711 #ifdef MF_REGISTER_dlerror
1712     __mf_register (p, n, MF_REGISTER_dlerror, "dlerror result");
1713 #endif
1714     MF_VALIDATE_EXTENT (p, n, __MF_CHECK_WRITE, "dlerror result");
1715   }
1716   return p;
1717 }
1718
1719
1720 WRAPPER2(void *, dlsym, void *handle, char *symbol)
1721 {
1722   size_t n;
1723   void *p;
1724   TRACE ("%s\n", __PRETTY_FUNCTION__);
1725   MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlsym handle");
1726   n = strlen (symbol);
1727   MF_VALIDATE_EXTENT (symbol, CLAMPADD(n, 1), __MF_CHECK_READ, "dlsym symbol");
1728   p = dlsym (handle, symbol);
1729   if (NULL != p) {
1730 #ifdef MF_REGISTER_dlsym
1731     __mf_register (p, 0, MF_REGISTER_dlsym, "dlsym result");
1732 #endif
1733     MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlsym result");
1734   }
1735   return p;
1736 }
1737
1738
1739 #if defined (HAVE_SYS_IPC_H) && defined (HAVE_SYS_SEM_H) && defined (HAVE_SYS_SHM_H)
1740
1741 WRAPPER2(int, semop, int semid, struct sembuf *sops, unsigned nsops)
1742 {
1743   TRACE ("%s\n", __PRETTY_FUNCTION__);
1744   MF_VALIDATE_EXTENT (sops, sizeof (*sops) * nsops, __MF_CHECK_READ,
1745     "semop sops");
1746   return semop (semid, sops, nsops);
1747 }
1748
1749
1750 #ifndef HAVE_UNION_SEMUN
1751 union semun {
1752         int val;                        /* value for SETVAL */
1753         struct semid_ds *buf;           /* buffer for IPC_STAT, IPC_SET */
1754         unsigned short int *array;      /* array for GETALL, SETALL */
1755         struct seminfo *__buf;          /* buffer for IPC_INFO */
1756 };
1757 #endif
1758 WRAPPER2(int, semctl, int semid, int semnum, int cmd, union semun arg)
1759 {
1760   TRACE ("%s\n", __PRETTY_FUNCTION__);
1761   switch (cmd) {
1762   case IPC_STAT:
1763     MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_WRITE,
1764       "semctl buf");
1765     break;
1766   case IPC_SET:
1767     MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_READ,
1768       "semctl buf");
1769     break;
1770   case GETALL:
1771     MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_WRITE,
1772       "semctl array");
1773   case SETALL:
1774     MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_READ,
1775       "semctl array");
1776     break;
1777 #ifdef IPC_INFO
1778   /* FreeBSD 5.1 And Cygwin headers include IPC_INFO but not the __buf field.  */
1779 #if !defined(__FreeBSD__) && !defined(__CYGWIN__)
1780   case IPC_INFO:
1781     MF_VALIDATE_EXTENT (arg.__buf, sizeof (*arg.__buf), __MF_CHECK_WRITE,
1782       "semctl __buf");
1783     break;
1784 #endif
1785 #endif
1786   default:
1787     break;
1788   }
1789   return semctl (semid, semnum, cmd, arg);
1790 }
1791
1792
1793 WRAPPER2(int, shmctl, int shmid, int cmd, struct shmid_ds *buf)
1794 {
1795   TRACE ("%s\n", __PRETTY_FUNCTION__);
1796   switch (cmd) {
1797   case IPC_STAT:
1798     MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_WRITE,
1799       "shmctl buf");
1800     break;
1801   case IPC_SET:
1802     MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ,
1803       "shmctl buf");
1804     break;
1805   default:
1806     break;
1807   }
1808   return shmctl (shmid, cmd, buf);
1809 }
1810
1811
1812 WRAPPER2(void *, shmat, int shmid, const void *shmaddr, int shmflg)
1813 {
1814   void *p;
1815   TRACE ("%s\n", __PRETTY_FUNCTION__);
1816   p = shmat (shmid, shmaddr, shmflg);
1817 #ifdef MF_REGISTER_shmat
1818   if (NULL != p) {
1819     struct shmid_ds buf;
1820     __mf_register (p, shmctl (shmid, IPC_STAT, &buf) ? 0 : buf.shm_segsz,
1821       MF_REGISTER_shmat, "shmat result");
1822   }
1823 #endif
1824   return p;
1825 }
1826
1827
1828 WRAPPER2(int, shmdt, const void *shmaddr)
1829 {
1830   int resp;
1831   TRACE ("%s\n", __PRETTY_FUNCTION__);
1832   resp = shmdt (shmaddr);
1833 #ifdef MF_REGISTER_shmat
1834   __mf_unregister ((void *)shmaddr, 0, MF_REGISTER_shmat);
1835 #endif
1836   return resp;
1837 }
1838
1839
1840 #endif /* HAVE_SYS_IPC/SEM/SHM_H */
1841
1842
1843
1844 /* ctype stuff.  This is host-specific by necessity, as the arrays
1845    that is used by most is*()/to*() macros are implementation-defined.  */
1846
1847 /* GLIBC 2.3 */
1848 #ifdef HAVE___CTYPE_B_LOC
1849 WRAPPER2(unsigned short **, __ctype_b_loc, void)
1850 {
1851   static unsigned short * last_buf = (void *) 0;
1852   static unsigned short ** last_ptr = (void *) 0;
1853   unsigned short ** ptr = (unsigned short **) __ctype_b_loc ();
1854   unsigned short * buf = * ptr;
1855   if (ptr != last_ptr)
1856     {
1857       /* XXX: unregister last_ptr? */
1858       last_ptr = ptr;
1859       __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_b_loc **");
1860     }
1861   if (buf != last_buf)
1862     {
1863       last_buf = buf;
1864       __mf_register ((void *) (last_buf - 128), 384 * sizeof(unsigned short), __MF_TYPE_STATIC,
1865                      "ctype_b_loc []");
1866     }
1867   return ptr;
1868 }
1869 #endif
1870
1871 #ifdef HAVE___CTYPE_TOUPPER_LOC
1872 WRAPPER2(int **, __ctype_toupper_loc, void)
1873 {
1874   static int * last_buf = (void *) 0;
1875   static int ** last_ptr = (void *) 0;
1876   int ** ptr = (int **) __ctype_toupper_loc ();
1877   int * buf = * ptr;
1878   if (ptr != last_ptr)
1879     {
1880       /* XXX: unregister last_ptr? */
1881       last_ptr = ptr;
1882       __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_toupper_loc **");
1883     }
1884   if (buf != last_buf)
1885     {
1886       last_buf = buf;
1887       __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC,
1888                      "ctype_toupper_loc []");
1889     }
1890   return ptr;
1891 }
1892 #endif
1893
1894 #ifdef HAVE___CTYPE_TOLOWER_LOC
1895 WRAPPER2(int **, __ctype_tolower_loc, void)
1896 {
1897   static int * last_buf = (void *) 0;
1898   static int ** last_ptr = (void *) 0;
1899   int ** ptr = (int **) __ctype_tolower_loc ();
1900   int * buf = * ptr;
1901   if (ptr != last_ptr)
1902     {
1903       /* XXX: unregister last_ptr? */
1904       last_ptr = ptr;
1905       __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_tolower_loc **");
1906     }
1907   if (buf != last_buf)
1908     {
1909       last_buf = buf;
1910       __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC,
1911                      "ctype_tolower_loc []");
1912     }
1913   return ptr;
1914 }
1915 #endif
1916
1917
1918 /* passwd/group related functions.  These register every (static) pointer value returned,
1919    and rely on libmudflap's quiet toleration of duplicate static registrations.  */
1920
1921 #ifdef HAVE_GETLOGIN
1922 WRAPPER2(char *, getlogin, void)
1923 {
1924   char *buf = getlogin ();
1925   if (buf != NULL)
1926     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
1927                    "getlogin() return");
1928   return buf;
1929 }
1930 #endif
1931
1932
1933 #ifdef HAVE_CUSERID
1934 WRAPPER2(char *, cuserid, char * buf)
1935 {
1936   if (buf != NULL)
1937     {
1938       MF_VALIDATE_EXTENT(buf, L_cuserid, __MF_CHECK_WRITE,
1939                          "cuserid destination");
1940       return cuserid (buf);
1941     }
1942   buf = cuserid (NULL);
1943   if (buf != NULL)
1944     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
1945                    "getcuserid() return");
1946   return buf;
1947 }
1948 #endif
1949
1950
1951 #ifdef HAVE_GETPWNAM
1952 WRAPPER2(struct passwd *, getpwnam, const char *name)
1953 {
1954   struct passwd *buf;
1955   MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
1956                      "getpwnam name");
1957   buf = getpwnam (name);
1958   if (buf != NULL)
1959     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
1960                    "getpw*() return");
1961   return buf;
1962 }
1963 #endif
1964
1965
1966 #ifdef HAVE_GETPWUID
1967 WRAPPER2(struct passwd *, getpwuid, uid_t uid)
1968 {
1969   struct passwd *buf;
1970   buf = getpwuid (uid);
1971   if (buf != NULL)
1972     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
1973                    "getpw*() return");
1974   return buf;
1975 }
1976 #endif
1977
1978
1979 #ifdef HAVE_GETGRNAM
1980 WRAPPER2(struct group *, getgrnam, const char *name)
1981 {
1982   struct group *buf;
1983   MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
1984                      "getgrnam name");
1985   buf = getgrnam (name);
1986   if (buf != NULL)
1987     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
1988                    "getgr*() return");
1989   return buf;
1990 }
1991 #endif
1992
1993
1994 #ifdef HAVE_GETGRGID
1995 WRAPPER2(struct group *, getgrgid, uid_t uid)
1996 {
1997   struct group *buf;
1998   buf = getgrgid (uid);
1999   if (buf != NULL)
2000     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
2001                    "getgr*() return");
2002   return buf;
2003 }
2004 #endif
2005
2006
2007 #ifdef HAVE_GETSERVENT
2008 WRAPPER2(struct servent *, getservent, void)
2009 {
2010   struct servent *buf;
2011   buf = getservent ();
2012   if (buf != NULL)
2013     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
2014                    "getserv*() return");
2015   return buf;
2016 }
2017 #endif
2018
2019
2020 #ifdef HAVE_GETSERVBYNAME
2021 WRAPPER2(struct servent *, getservbyname, const char *name, const char *proto)
2022 {
2023   struct servent *buf;
2024   MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
2025                      "getservbyname name");
2026   MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ,
2027                      "getservbyname proto");
2028   buf = getservbyname (name, proto);
2029   if (buf != NULL)
2030     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
2031                    "getserv*() return");
2032   return buf;
2033 }
2034 #endif
2035
2036
2037 #ifdef HAVE_GETSERVBYPORT
2038 WRAPPER2(struct servent *, getservbyport, int port, const char *proto)
2039 {
2040   struct servent *buf;
2041   MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ,
2042                      "getservbyport proto");
2043   buf = getservbyport (port, proto);
2044   if (buf != NULL)
2045     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
2046                    "getserv*() return");
2047   return buf;
2048 }
2049 #endif
2050
2051
2052 #ifdef HAVE_GAI_STRERROR
2053 WRAPPER2(const char *, gai_strerror, int errcode)
2054 {
2055   const char *buf;
2056   buf = gai_strerror (errcode);
2057   if (buf != NULL)
2058     __mf_register ((void *) buf, strlen(buf)+1, __MF_TYPE_STATIC,
2059                    "gai_strerror() return");
2060   return buf;
2061 }
2062 #endif
2063
2064
2065 #ifdef HAVE_GETMNTENT
2066 WRAPPER2(struct mntent *, getmntent, FILE *filep)
2067 {
2068   struct mntent *m;
2069   static struct mntent *last = NULL;
2070
2071   MF_VALIDATE_EXTENT (filep, sizeof (*filep), __MF_CHECK_WRITE,
2072     "getmntent stream");
2073 #define UR(field) __mf_unregister(last->field, strlen (last->field)+1, __MF_TYPE_STATIC)
2074   if (last)
2075     {
2076       UR (mnt_fsname);
2077       UR (mnt_dir);
2078       UR (mnt_type);
2079       UR (mnt_opts);
2080       __mf_unregister (last, sizeof (*last), __MF_TYPE_STATIC);
2081     }
2082 #undef UR
2083
2084   m = getmntent (filep);
2085   last = m;
2086
2087 #define R(field) __mf_register(last->field, strlen (last->field)+1, __MF_TYPE_STATIC, "mntent " #field)
2088   if (m)
2089     {
2090       R (mnt_fsname);
2091       R (mnt_dir);
2092       R (mnt_type);
2093       R (mnt_opts);
2094       __mf_register (last, sizeof (*last), __MF_TYPE_STATIC, "getmntent result");
2095     }
2096 #undef R
2097
2098   return m;
2099 }
2100 #endif
2101
2102
2103 #ifdef HAVE_INET_NTOA
2104 WRAPPER2(char *, inet_ntoa, struct in_addr in)
2105 {
2106   static char *last_buf = NULL;
2107   char *buf;
2108   if (last_buf)
2109     __mf_unregister (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC);
2110   buf = inet_ntoa (in);
2111   last_buf = buf;
2112   if (buf)
2113     __mf_register (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC, "inet_ntoa result");
2114   return buf;
2115 }
2116 #endif
2117
2118
2119 #ifdef HAVE_GETPROTOENT
2120 WRAPPER2(struct protoent *, getprotoent, void)
2121 {
2122   struct protoent *buf;
2123   buf = getprotoent ();
2124   if (buf != NULL)
2125     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, "getproto*() return");
2126   return buf;
2127 }
2128 #endif
2129
2130
2131 #ifdef HAVE_GETPROTOBYNAME
2132 WRAPPER2(struct protoent *, getprotobyname, const char *name)
2133 {
2134   struct protoent *buf;
2135   MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
2136                      "getprotobyname name");
2137   buf = getprotobyname (name);
2138   if (buf != NULL)
2139     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
2140                    "getproto*() return");
2141   return buf;
2142 }
2143 #endif
2144
2145
2146 #ifdef HAVE_GETPROTOBYNUMBER
2147 WRAPPER2(struct protoent *, getprotobynumber, int port)
2148 {
2149   struct protoent *buf;
2150   buf = getprotobynumber (port);
2151   if (buf != NULL)
2152     __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
2153                    "getproto*() return");
2154   return buf;
2155 }
2156 #endif