1169695Skan/* Mudflap: narrow-pointer bounds-checking by tree rewriting. 2169695Skan Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. 3169695Skan Contributed by Frank Ch. Eigler <fche@redhat.com> 4169695Skan and Graydon Hoare <graydon@redhat.com> 5169695Skan 6169695SkanThis file is part of GCC. 7169695Skan 8169695SkanGCC is free software; you can redistribute it and/or modify it under 9169695Skanthe terms of the GNU General Public License as published by the Free 10169695SkanSoftware Foundation; either version 2, or (at your option) any later 11169695Skanversion. 12169695Skan 13169695SkanIn addition to the permissions in the GNU General Public License, the 14169695SkanFree Software Foundation gives you unlimited permission to link the 15169695Skancompiled version of this file into combinations with other programs, 16169695Skanand to distribute those combinations without any restriction coming 17169695Skanfrom the use of this file. (The General Public License restrictions 18169695Skando apply in other respects; for example, they cover modification of 19169695Skanthe file, and distribution when not linked into a combine 20169695Skanexecutable.) 21169695Skan 22169695SkanGCC is distributed in the hope that it will be useful, but WITHOUT ANY 23169695SkanWARRANTY; without even the implied warranty of MERCHANTABILITY or 24169695SkanFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 25169695Skanfor more details. 26169695Skan 27169695SkanYou should have received a copy of the GNU General Public License 28169695Skanalong with GCC; see the file COPYING. If not, write to the Free 29169695SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 30169695Skan02110-1301, USA. */ 31169695Skan 32169695Skan 33169695Skan#include "config.h" 34169695Skan 35169695Skan#ifndef HAVE_SOCKLEN_T 36169695Skan#define socklen_t int 37169695Skan#endif 38169695Skan 39169695Skan/* These attempt to coax various unix flavours to declare all our 40169695Skan needed tidbits in the system headers. */ 41169695Skan#if !defined(__FreeBSD__) && !defined(__APPLE__) 42169695Skan#define _POSIX_SOURCE 43169695Skan#endif /* Some BSDs break <sys/socket.h> if this is defined. */ 44169695Skan#define _GNU_SOURCE 45169695Skan#define _XOPEN_SOURCE 46169695Skan#define _BSD_TYPES 47169695Skan#define __EXTENSIONS__ 48169695Skan#define _ALL_SOURCE 49169695Skan#define _LARGE_FILE_API 50169695Skan#define _LARGEFILE64_SOURCE 51169695Skan#define _XOPEN_SOURCE_EXTENDED 1 52169695Skan 53169695Skan#include <string.h> 54169695Skan#include <stdarg.h> 55169695Skan#include <stdio.h> 56169695Skan#include <stdlib.h> 57169695Skan#include <sys/stat.h> 58169695Skan#include <sys/time.h> 59169695Skan#include <sys/types.h> 60169695Skan#include <unistd.h> 61169695Skan#include <assert.h> 62169695Skan#include <errno.h> 63169695Skan#include <limits.h> 64169695Skan#include <time.h> 65169695Skan#include <ctype.h> 66169695Skan#ifdef HAVE_DLFCN_H 67169695Skan#include <dlfcn.h> 68169695Skan#endif 69169695Skan#ifdef HAVE_DIRENT_H 70169695Skan#include <dirent.h> 71169695Skan#endif 72169695Skan#ifdef HAVE_SYS_SOCKET_H 73169695Skan#include <sys/socket.h> 74169695Skan#endif 75169695Skan#ifdef HAVE_NETDB_H 76169695Skan#include <netdb.h> 77169695Skan#endif 78169695Skan#ifdef HAVE_SYS_WAIT_H 79169695Skan#include <sys/wait.h> 80169695Skan#endif 81169695Skan#ifdef HAVE_SYS_IPC_H 82169695Skan#include <sys/ipc.h> 83169695Skan#endif 84169695Skan#ifdef HAVE_SYS_SEM_H 85169695Skan#include <sys/sem.h> 86169695Skan#endif 87169695Skan#ifdef HAVE_SYS_SHM_H 88169695Skan#include <sys/shm.h> 89169695Skan#endif 90169695Skan#ifdef HAVE_PWD_H 91169695Skan#include <pwd.h> 92169695Skan#endif 93169695Skan#ifdef HAVE_GRP_H 94169695Skan#include <grp.h> 95169695Skan#endif 96169695Skan#ifdef HAVE_MNTENT_H 97169695Skan#include <mntent.h> 98169695Skan#endif 99169695Skan#ifdef HAVE_SYS_SOCKET_H 100169695Skan#include <sys/socket.h> 101169695Skan#endif 102169695Skan#ifdef HAVE_NETINET_IN_H 103169695Skan#include <netinet/in.h> 104169695Skan#endif 105169695Skan#ifdef HAVE_ARPA_INET_H 106169695Skan#include <arpa/inet.h> 107169695Skan#endif 108169695Skan 109169695Skan#include "mf-runtime.h" 110169695Skan#include "mf-impl.h" 111169695Skan 112169695Skan#ifdef _MUDFLAP 113169695Skan#error "Do not compile this file with -fmudflap!" 114169695Skan#endif 115169695Skan 116169695Skan 117169695Skan/* A bunch of independent stdlib/unistd hook functions, all 118169695Skan intercepted by mf-runtime.h macros. */ 119169695Skan 120169695Skan#ifndef HAVE_STRNLEN 121169695Skanstatic inline size_t (strnlen) (const char* str, size_t n) 122169695Skan{ 123169695Skan const char *s; 124169695Skan 125169695Skan for (s = str; n && *s; ++s, --n) 126169695Skan ; 127169695Skan return (s - str); 128169695Skan} 129169695Skan#endif 130169695Skan 131169695Skan 132169695Skan/* str*,mem*,b* */ 133169695Skan 134169695SkanWRAPPER2(void *, memcpy, void *dest, const void *src, size_t n) 135169695Skan{ 136169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 137169695Skan MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memcpy source"); 138169695Skan MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memcpy dest"); 139169695Skan return memcpy (dest, src, n); 140169695Skan} 141169695Skan 142169695Skan 143169695SkanWRAPPER2(void *, memmove, void *dest, const void *src, size_t n) 144169695Skan{ 145169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 146169695Skan MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memmove src"); 147169695Skan MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memmove dest"); 148169695Skan return memmove (dest, src, n); 149169695Skan} 150169695Skan 151169695Skan 152169695SkanWRAPPER2(void *, memset, void *s, int c, size_t n) 153169695Skan{ 154169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 155169695Skan MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "memset dest"); 156169695Skan return memset (s, c, n); 157169695Skan} 158169695Skan 159169695Skan 160169695SkanWRAPPER2(int, memcmp, const void *s1, const void *s2, size_t n) 161169695Skan{ 162169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 163169695Skan MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "memcmp 1st arg"); 164169695Skan MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "memcmp 2nd arg"); 165169695Skan return memcmp (s1, s2, n); 166169695Skan} 167169695Skan 168169695Skan 169169695SkanWRAPPER2(void *, memchr, const void *s, int c, size_t n) 170169695Skan{ 171169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 172169695Skan MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memchr region"); 173169695Skan return memchr (s, c, n); 174169695Skan} 175169695Skan 176169695Skan 177169695Skan#ifdef HAVE_MEMRCHR 178169695SkanWRAPPER2(void *, memrchr, const void *s, int c, size_t n) 179169695Skan{ 180169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 181169695Skan MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memrchr region"); 182169695Skan return memrchr (s, c, n); 183169695Skan} 184169695Skan#endif 185169695Skan 186169695Skan 187169695SkanWRAPPER2(char *, strcpy, char *dest, const char *src) 188169695Skan{ 189169695Skan /* nb: just because strlen(src) == n doesn't mean (src + n) or (src + n + 190169695Skan 1) are valid pointers. the allocated object might have size < n. 191169695Skan check anyways. */ 192169695Skan 193169695Skan size_t n = strlen (src); 194169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 195169695Skan MF_VALIDATE_EXTENT(src, CLAMPADD(n, 1), __MF_CHECK_READ, "strcpy src"); 196169695Skan MF_VALIDATE_EXTENT(dest, CLAMPADD(n, 1), __MF_CHECK_WRITE, "strcpy dest"); 197169695Skan return strcpy (dest, src); 198169695Skan} 199169695Skan 200169695Skan 201169695Skan#ifdef HAVE_STRNCPY 202169695SkanWRAPPER2(char *, strncpy, char *dest, const char *src, size_t n) 203169695Skan{ 204169695Skan size_t len = strnlen (src, n); 205169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 206169695Skan MF_VALIDATE_EXTENT(src, len, __MF_CHECK_READ, "strncpy src"); 207169695Skan MF_VALIDATE_EXTENT(dest, len, __MF_CHECK_WRITE, "strncpy dest"); /* nb: strNcpy */ 208169695Skan return strncpy (dest, src, n); 209169695Skan} 210169695Skan#endif 211169695Skan 212169695Skan 213169695SkanWRAPPER2(char *, strcat, char *dest, const char *src) 214169695Skan{ 215169695Skan size_t dest_sz; 216169695Skan size_t src_sz; 217169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 218169695Skan dest_sz = strlen (dest); 219169695Skan src_sz = strlen (src); 220169695Skan MF_VALIDATE_EXTENT(src, CLAMPADD(src_sz, 1), __MF_CHECK_READ, "strcat src"); 221169695Skan MF_VALIDATE_EXTENT(dest, CLAMPADD(dest_sz, CLAMPADD(src_sz, 1)), 222169695Skan __MF_CHECK_WRITE, "strcat dest"); 223169695Skan return strcat (dest, src); 224169695Skan} 225169695Skan 226169695Skan 227169695SkanWRAPPER2(char *, strncat, char *dest, const char *src, size_t n) 228169695Skan{ 229169695Skan 230169695Skan /* nb: validating the extents (s,n) might be a mistake for two reasons. 231169695Skan 232169695Skan (1) the string s might be shorter than n chars, and n is just a 233169695Skan poor choice by the programmer. this is not a "true" error in the 234169695Skan sense that the call to strncat would still be ok. 235169695Skan 236169695Skan (2) we could try to compensate for case (1) by calling strlen(s) and 237169695Skan using that as a bound for the extent to verify, but strlen might fall off 238169695Skan the end of a non-terminated string, leading to a false positive. 239169695Skan 240169695Skan so we will call strnlen(s,n) and use that as a bound. 241169695Skan 242169695Skan if strnlen returns a length beyond the end of the registered extent 243169695Skan associated with s, there is an error: the programmer's estimate for n is 244169695Skan too large _AND_ the string s is unterminated, in which case they'd be 245169695Skan about to touch memory they don't own while calling strncat. 246169695Skan 247169695Skan this same logic applies to further uses of strnlen later down in this 248169695Skan file. */ 249169695Skan 250169695Skan size_t src_sz; 251169695Skan size_t dest_sz; 252169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 253169695Skan src_sz = strnlen (src, n); 254169695Skan dest_sz = strnlen (dest, n); 255169695Skan MF_VALIDATE_EXTENT(src, src_sz, __MF_CHECK_READ, "strncat src"); 256169695Skan MF_VALIDATE_EXTENT(dest, (CLAMPADD(dest_sz, CLAMPADD(src_sz, 1))), 257169695Skan __MF_CHECK_WRITE, "strncat dest"); 258169695Skan return strncat (dest, src, n); 259169695Skan} 260169695Skan 261169695Skan 262169695SkanWRAPPER2(int, strcmp, const char *s1, const char *s2) 263169695Skan{ 264169695Skan size_t s1_sz; 265169695Skan size_t s2_sz; 266169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 267169695Skan s1_sz = strlen (s1); 268169695Skan s2_sz = strlen (s2); 269169695Skan MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcmp 1st arg"); 270169695Skan MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_WRITE, "strcmp 2nd arg"); 271169695Skan return strcmp (s1, s2); 272169695Skan} 273169695Skan 274169695Skan 275169695SkanWRAPPER2(int, strcasecmp, const char *s1, const char *s2) 276169695Skan{ 277169695Skan size_t s1_sz; 278169695Skan size_t s2_sz; 279169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 280169695Skan s1_sz = strlen (s1); 281169695Skan s2_sz = strlen (s2); 282169695Skan MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcasecmp 1st arg"); 283169695Skan MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_READ, "strcasecmp 2nd arg"); 284169695Skan return strcasecmp (s1, s2); 285169695Skan} 286169695Skan 287169695Skan 288169695SkanWRAPPER2(int, strncmp, const char *s1, const char *s2, size_t n) 289169695Skan{ 290169695Skan size_t s1_sz; 291169695Skan size_t s2_sz; 292169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 293169695Skan s1_sz = strnlen (s1, n); 294169695Skan s2_sz = strnlen (s2, n); 295169695Skan MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncmp 1st arg"); 296169695Skan MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncmp 2nd arg"); 297169695Skan return strncmp (s1, s2, n); 298169695Skan} 299169695Skan 300169695Skan 301169695SkanWRAPPER2(int, strncasecmp, const char *s1, const char *s2, size_t n) 302169695Skan{ 303169695Skan size_t s1_sz; 304169695Skan size_t s2_sz; 305169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 306169695Skan s1_sz = strnlen (s1, n); 307169695Skan s2_sz = strnlen (s2, n); 308169695Skan MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncasecmp 1st arg"); 309169695Skan MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncasecmp 2nd arg"); 310169695Skan return strncasecmp (s1, s2, n); 311169695Skan} 312169695Skan 313169695Skan 314169695SkanWRAPPER2(char *, strdup, const char *s) 315169695Skan{ 316169695Skan DECLARE(void *, malloc, size_t sz); 317169695Skan char *result; 318169695Skan size_t n = strlen (s); 319169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 320169695Skan MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strdup region"); 321169695Skan result = (char *)CALL_REAL(malloc, 322169695Skan CLAMPADD(CLAMPADD(n,1), 323169695Skan CLAMPADD(__mf_opts.crumple_zone, 324169695Skan __mf_opts.crumple_zone))); 325169695Skan 326169695Skan if (UNLIKELY(! result)) return result; 327169695Skan 328169695Skan result += __mf_opts.crumple_zone; 329169695Skan memcpy (result, s, n); 330169695Skan result[n] = '\0'; 331169695Skan 332169695Skan __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strdup region"); 333169695Skan return result; 334169695Skan} 335169695Skan 336169695Skan 337169695SkanWRAPPER2(char *, strndup, const char *s, size_t n) 338169695Skan{ 339169695Skan DECLARE(void *, malloc, size_t sz); 340169695Skan char *result; 341169695Skan size_t sz = strnlen (s, n); 342169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 343169695Skan MF_VALIDATE_EXTENT(s, sz, __MF_CHECK_READ, "strndup region"); /* nb: strNdup */ 344169695Skan 345169695Skan /* note: strndup still adds a \0, even with the N limit! */ 346169695Skan result = (char *)CALL_REAL(malloc, 347169695Skan CLAMPADD(CLAMPADD(n,1), 348169695Skan CLAMPADD(__mf_opts.crumple_zone, 349169695Skan __mf_opts.crumple_zone))); 350169695Skan 351169695Skan if (UNLIKELY(! result)) return result; 352169695Skan 353169695Skan result += __mf_opts.crumple_zone; 354169695Skan memcpy (result, s, n); 355169695Skan result[n] = '\0'; 356169695Skan 357169695Skan __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strndup region"); 358169695Skan return result; 359169695Skan} 360169695Skan 361169695Skan 362169695SkanWRAPPER2(char *, strchr, const char *s, int c) 363169695Skan{ 364169695Skan size_t n; 365169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 366169695Skan n = strlen (s); 367169695Skan MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strchr region"); 368169695Skan return strchr (s, c); 369169695Skan} 370169695Skan 371169695Skan 372169695SkanWRAPPER2(char *, strrchr, const char *s, int c) 373169695Skan{ 374169695Skan size_t n; 375169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 376169695Skan n = strlen (s); 377169695Skan MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strrchr region"); 378169695Skan return strrchr (s, c); 379169695Skan} 380169695Skan 381169695Skan 382169695SkanWRAPPER2(char *, strstr, const char *haystack, const char *needle) 383169695Skan{ 384169695Skan size_t haystack_sz; 385169695Skan size_t needle_sz; 386169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 387169695Skan haystack_sz = strlen (haystack); 388169695Skan needle_sz = strlen (needle); 389169695Skan MF_VALIDATE_EXTENT(haystack, CLAMPADD(haystack_sz, 1), __MF_CHECK_READ, "strstr haystack"); 390169695Skan MF_VALIDATE_EXTENT(needle, CLAMPADD(needle_sz, 1), __MF_CHECK_READ, "strstr needle"); 391169695Skan return strstr (haystack, needle); 392169695Skan} 393169695Skan 394169695Skan 395169695Skan#ifdef HAVE_MEMMEM 396169695SkanWRAPPER2(void *, memmem, 397169695Skan const void *haystack, size_t haystacklen, 398169695Skan const void *needle, size_t needlelen) 399169695Skan{ 400169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 401169695Skan MF_VALIDATE_EXTENT(haystack, haystacklen, __MF_CHECK_READ, "memmem haystack"); 402169695Skan MF_VALIDATE_EXTENT(needle, needlelen, __MF_CHECK_READ, "memmem needle"); 403169695Skan return memmem (haystack, haystacklen, needle, needlelen); 404169695Skan} 405169695Skan#endif 406169695Skan 407169695Skan 408169695SkanWRAPPER2(size_t, strlen, const char *s) 409169695Skan{ 410169695Skan size_t result = strlen (s); 411169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 412169695Skan MF_VALIDATE_EXTENT(s, CLAMPADD(result, 1), __MF_CHECK_READ, "strlen region"); 413169695Skan return result; 414169695Skan} 415169695Skan 416169695Skan 417169695SkanWRAPPER2(size_t, strnlen, const char *s, size_t n) 418169695Skan{ 419169695Skan size_t result = strnlen (s, n); 420169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 421169695Skan MF_VALIDATE_EXTENT(s, result, __MF_CHECK_READ, "strnlen region"); 422169695Skan return result; 423169695Skan} 424169695Skan 425169695Skan 426169695SkanWRAPPER2(void, bzero, void *s, size_t n) 427169695Skan{ 428169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 429169695Skan MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "bzero region"); 430169695Skan bzero (s, n); 431169695Skan} 432169695Skan 433169695Skan 434169695Skan#undef bcopy 435169695SkanWRAPPER2(void, bcopy, const void *src, void *dest, size_t n) 436169695Skan{ 437169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 438169695Skan MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "bcopy src"); 439169695Skan MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "bcopy dest"); 440169695Skan bcopy (src, dest, n); 441169695Skan} 442169695Skan 443169695Skan 444169695Skan#undef bcmp 445169695SkanWRAPPER2(int, bcmp, const void *s1, const void *s2, size_t n) 446169695Skan{ 447169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 448169695Skan MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "bcmp 1st arg"); 449169695Skan MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "bcmp 2nd arg"); 450169695Skan return bcmp (s1, s2, n); 451169695Skan} 452169695Skan 453169695Skan 454169695SkanWRAPPER2(char *, index, const char *s, int c) 455169695Skan{ 456169695Skan size_t n = strlen (s); 457169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 458169695Skan MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "index region"); 459169695Skan return index (s, c); 460169695Skan} 461169695Skan 462169695Skan 463169695SkanWRAPPER2(char *, rindex, const char *s, int c) 464169695Skan{ 465169695Skan size_t n = strlen (s); 466169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 467169695Skan MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "rindex region"); 468169695Skan return rindex (s, c); 469169695Skan} 470169695Skan 471169695Skan/* XXX: stpcpy, memccpy */ 472169695Skan 473169695Skan/* XXX: *printf,*scanf */ 474169695Skan 475169695Skan/* XXX: setjmp, longjmp */ 476169695Skan 477169695SkanWRAPPER2(char *, asctime, struct tm *tm) 478169695Skan{ 479169695Skan static char *reg_result = NULL; 480169695Skan char *result; 481169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 482169695Skan MF_VALIDATE_EXTENT(tm, sizeof (struct tm), __MF_CHECK_READ, "asctime tm"); 483169695Skan result = asctime (tm); 484169695Skan if (reg_result == NULL) 485169695Skan { 486169695Skan __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "asctime string"); 487169695Skan reg_result = result; 488169695Skan } 489169695Skan return result; 490169695Skan} 491169695Skan 492169695Skan 493169695SkanWRAPPER2(char *, ctime, const time_t *timep) 494169695Skan{ 495169695Skan static char *reg_result = NULL; 496169695Skan char *result; 497169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 498169695Skan MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "ctime time"); 499169695Skan result = ctime (timep); 500169695Skan if (reg_result == NULL) 501169695Skan { 502169695Skan /* XXX: what if asctime and ctime return the same static ptr? */ 503169695Skan __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "ctime string"); 504169695Skan reg_result = result; 505169695Skan } 506169695Skan return result; 507169695Skan} 508169695Skan 509169695Skan 510169695SkanWRAPPER2(struct tm*, localtime, const time_t *timep) 511169695Skan{ 512169695Skan static struct tm *reg_result = NULL; 513169695Skan struct tm *result; 514169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 515169695Skan MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "localtime time"); 516169695Skan result = localtime (timep); 517169695Skan if (reg_result == NULL) 518169695Skan { 519169695Skan __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "localtime tm"); 520169695Skan reg_result = result; 521169695Skan } 522169695Skan return result; 523169695Skan} 524169695Skan 525169695Skan 526169695SkanWRAPPER2(struct tm*, gmtime, const time_t *timep) 527169695Skan{ 528169695Skan static struct tm *reg_result = NULL; 529169695Skan struct tm *result; 530169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 531169695Skan MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "gmtime time"); 532169695Skan result = gmtime (timep); 533169695Skan if (reg_result == NULL) 534169695Skan { 535169695Skan __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "gmtime tm"); 536169695Skan reg_result = result; 537169695Skan } 538169695Skan return result; 539169695Skan} 540169695Skan 541169695Skan 542169695Skan/* EL start */ 543169695Skan 544169695Skan/* The following indicate if the result of the corresponding function 545169695Skan * should be explicitly un/registered by the wrapper 546169695Skan*/ 547169695Skan 548169695Skan#ifdef __FreeBSD__ 549169695Skan#define MF_REGISTER_fopen __MF_TYPE_STATIC 550169695Skan#else 551169695Skan#undef MF_REGISTER_fopen 552169695Skan#endif 553169695Skan#define MF_RESULT_SIZE_fopen (sizeof (FILE)) 554169695Skan 555169695Skan#undef MF_REGISTER_opendir 556169695Skan#define MF_RESULT_SIZE_opendir 0 /* (sizeof (DIR)) */ 557169695Skan#undef MF_REGISTER_readdir 558169695Skan#define MF_REGISTER_gethostbyname __MF_TYPE_STATIC 559169695Skan#undef MF_REGISTER_gethostbyname_items 560169695Skan#undef MF_REGISTER_dlopen 561169695Skan#undef MF_REGISTER_dlerror 562169695Skan#undef MF_REGISTER_dlsym 563169695Skan#define MF_REGISTER_shmat __MF_TYPE_GUESS 564169695Skan 565169695Skan 566169695Skan#include <time.h> 567169695SkanWRAPPER2(time_t, time, time_t *timep) 568169695Skan{ 569169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 570169695Skan if (NULL != timep) 571169695Skan MF_VALIDATE_EXTENT (timep, sizeof (*timep), __MF_CHECK_WRITE, 572169695Skan "time timep"); 573169695Skan return time (timep); 574169695Skan} 575169695Skan 576169695Skan 577169695SkanWRAPPER2(char *, strerror, int errnum) 578169695Skan{ 579169695Skan char *p; 580169695Skan static char * last_strerror = NULL; 581169695Skan 582169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 583169695Skan p = strerror (errnum); 584169695Skan if (last_strerror != NULL) 585169695Skan __mf_unregister (last_strerror, 0, __MF_TYPE_STATIC); 586169695Skan if (NULL != p) 587169695Skan __mf_register (p, strlen (p) + 1, __MF_TYPE_STATIC, "strerror result"); 588169695Skan last_strerror = p; 589169695Skan return p; 590169695Skan} 591169695Skan 592169695Skan 593169695Skan 594169695Skan/* An auxiliary data structure for tracking the hand-made stdio 595169695Skan buffers we generate during the fopen/fopen64 hooks. In a civilized 596169695Skan language, this would be a simple dynamically sized FILE*->char* 597169695Skan lookup table, but this is C and we get to do it by hand. */ 598169695Skanstruct mf_filebuffer 599169695Skan{ 600169695Skan FILE *file; 601169695Skan char *buffer; 602169695Skan struct mf_filebuffer *next; 603169695Skan}; 604169695Skanstatic struct mf_filebuffer *mf_filebuffers = NULL; 605169695Skan 606169695Skanstatic void 607169695Skanmkbuffer (FILE *f) 608169695Skan{ 609169695Skan /* Reset any buffer automatically provided by libc, since this may 610169695Skan have been done via mechanisms that libmudflap couldn't 611169695Skan intercept. */ 612169695Skan int rc; 613169695Skan size_t bufsize = BUFSIZ; 614169695Skan int bufmode; 615169695Skan char *buffer = malloc (bufsize); 616169695Skan struct mf_filebuffer *b = malloc (sizeof (struct mf_filebuffer)); 617169695Skan assert ((buffer != NULL) && (b != NULL)); 618169695Skan 619169695Skan /* Link it into list. */ 620169695Skan b->file = f; 621169695Skan b->buffer = buffer; 622169695Skan b->next = mf_filebuffers; 623169695Skan mf_filebuffers = b; 624169695Skan 625169695Skan /* Determine how the file is supposed to be buffered at the moment. */ 626169695Skan bufmode = fileno (f) == 2 ? _IONBF : (isatty (fileno (f)) ? _IOLBF : _IOFBF); 627169695Skan 628169695Skan rc = setvbuf (f, buffer, bufmode, bufsize); 629169695Skan assert (rc == 0); 630169695Skan} 631169695Skan 632169695Skanstatic void 633169695Skanunmkbuffer (FILE *f) 634169695Skan{ 635169695Skan struct mf_filebuffer *b = mf_filebuffers; 636169695Skan struct mf_filebuffer **pb = & mf_filebuffers; 637169695Skan while (b != NULL) 638169695Skan { 639169695Skan if (b->file == f) 640169695Skan { 641169695Skan *pb = b->next; 642169695Skan free (b->buffer); 643169695Skan free (b); 644169695Skan return; 645169695Skan } 646169695Skan pb = & b->next; 647169695Skan b = b->next; 648169695Skan } 649169695Skan} 650169695Skan 651169695Skan 652169695Skan 653169695SkanWRAPPER2(FILE *, fopen, const char *path, const char *mode) 654169695Skan{ 655169695Skan size_t n; 656169695Skan FILE *p; 657169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 658169695Skan 659169695Skan n = strlen (path); 660169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen path"); 661169695Skan 662169695Skan n = strlen (mode); 663169695Skan MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen mode"); 664169695Skan 665169695Skan p = fopen (path, mode); 666169695Skan if (NULL != p) { 667169695Skan#ifdef MF_REGISTER_fopen 668169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen result"); 669169695Skan#endif 670169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen result"); 671169695Skan 672169695Skan mkbuffer (p); 673169695Skan } 674169695Skan 675169695Skan return p; 676169695Skan} 677169695Skan 678169695Skan 679169695SkanWRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode, size_t size) 680169695Skan{ 681169695Skan int rc = 0; 682169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 683169695Skan 684169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, "setvbuf stream"); 685169695Skan 686169695Skan unmkbuffer (stream); 687169695Skan 688169695Skan if (buf != NULL) 689169695Skan MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_WRITE, "setvbuf buffer"); 690169695Skan 691169695Skan /* Override the user only if it's an auto-allocated buffer request. Otherwise 692169695Skan assume that the supplied buffer is already known to libmudflap. */ 693169695Skan if ((buf == NULL) && ((mode == _IOFBF) || (mode == _IOLBF))) 694169695Skan mkbuffer (stream); 695169695Skan else 696169695Skan rc = setvbuf (stream, buf, mode, size); 697169695Skan 698169695Skan return rc; 699169695Skan} 700169695Skan 701169695Skan 702169695Skan#ifdef HAVE_SETBUF 703169695SkanWRAPPER2(int, setbuf, FILE* stream, char *buf) 704169695Skan{ 705169695Skan return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ); 706169695Skan} 707169695Skan#endif 708169695Skan 709169695Skan#ifdef HAVE_SETBUFFER 710169695SkanWRAPPER2(int, setbuffer, FILE* stream, char *buf, size_t sz) 711169695Skan{ 712169695Skan return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, sz); 713169695Skan} 714169695Skan#endif 715169695Skan 716169695Skan#ifdef HAVE_SETLINEBUF 717169695SkanWRAPPER2(int, setlinebuf, FILE* stream) 718169695Skan{ 719169695Skan return __mfwrap_setvbuf(stream, NULL, _IOLBF, 0); 720169695Skan} 721169695Skan#endif 722169695Skan 723169695Skan 724169695Skan 725169695SkanWRAPPER2(FILE *, fdopen, int fd, const char *mode) 726169695Skan{ 727169695Skan size_t n; 728169695Skan FILE *p; 729169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 730169695Skan 731169695Skan n = strlen (mode); 732169695Skan MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fdopen mode"); 733169695Skan 734169695Skan p = fdopen (fd, mode); 735169695Skan if (NULL != p) { 736169695Skan#ifdef MF_REGISTER_fopen 737169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fdopen result"); 738169695Skan#endif 739169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fdopen result"); 740169695Skan 741169695Skan mkbuffer (p); 742169695Skan } 743169695Skan 744169695Skan return p; 745169695Skan} 746169695Skan 747169695Skan 748169695SkanWRAPPER2(FILE *, freopen, const char *path, const char *mode, FILE *s) 749169695Skan{ 750169695Skan size_t n; 751169695Skan FILE *p; 752169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 753169695Skan 754169695Skan n = strlen (path); 755169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen path"); 756169695Skan 757169695Skan MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen stream"); 758169695Skan unmkbuffer (s); 759169695Skan 760169695Skan n = strlen (mode); 761169695Skan MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen mode"); 762169695Skan 763169695Skan p = freopen (path, mode, s); 764169695Skan if (NULL != p) { 765169695Skan#ifdef MF_REGISTER_fopen 766169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen result"); 767169695Skan#endif 768169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen result"); 769169695Skan 770169695Skan mkbuffer (p); 771169695Skan } 772169695Skan 773169695Skan return p; 774169695Skan} 775169695Skan 776169695Skan 777169695Skan#ifdef HAVE_FOPEN64 778169695SkanWRAPPER2(FILE *, fopen64, const char *path, const char *mode) 779169695Skan{ 780169695Skan size_t n; 781169695Skan FILE *p; 782169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 783169695Skan 784169695Skan n = strlen (path); 785169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 path"); 786169695Skan 787169695Skan n = strlen (mode); 788169695Skan MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 mode"); 789169695Skan 790169695Skan p = fopen64 (path, mode); 791169695Skan if (NULL != p) { 792169695Skan#ifdef MF_REGISTER_fopen 793169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen64 result"); 794169695Skan#endif 795169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen64 result"); 796169695Skan 797169695Skan mkbuffer (p); 798169695Skan } 799169695Skan 800169695Skan return p; 801169695Skan} 802169695Skan#endif 803169695Skan 804169695Skan 805169695Skan#ifdef HAVE_FREOPEN64 806169695SkanWRAPPER2(FILE *, freopen64, const char *path, const char *mode, FILE *s) 807169695Skan{ 808169695Skan size_t n; 809169695Skan FILE *p; 810169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 811169695Skan 812169695Skan n = strlen (path); 813169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 path"); 814169695Skan 815169695Skan MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen64 stream"); 816169695Skan unmkbuffer (s); 817169695Skan 818169695Skan n = strlen (mode); 819169695Skan MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 mode"); 820169695Skan 821169695Skan p = freopen (path, mode, s); 822169695Skan if (NULL != p) { 823169695Skan#ifdef MF_REGISTER_fopen 824169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen64 result"); 825169695Skan#endif 826169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen64 result"); 827169695Skan 828169695Skan mkbuffer (p); 829169695Skan } 830169695Skan 831169695Skan return p; 832169695Skan} 833169695Skan#endif 834169695Skan 835169695Skan 836169695SkanWRAPPER2(int, fclose, FILE *stream) 837169695Skan{ 838169695Skan int resp; 839169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 840169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 841169695Skan "fclose stream"); 842169695Skan resp = fclose (stream); 843169695Skan#ifdef MF_REGISTER_fopen 844169695Skan __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen); 845169695Skan#endif 846169695Skan unmkbuffer (stream); 847169695Skan 848169695Skan return resp; 849169695Skan} 850169695Skan 851169695Skan 852169695SkanWRAPPER2(size_t, fread, void *ptr, size_t size, size_t nmemb, FILE *stream) 853169695Skan{ 854169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 855169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 856169695Skan "fread stream"); 857169695Skan MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_WRITE, "fread buffer"); 858169695Skan return fread (ptr, size, nmemb, stream); 859169695Skan} 860169695Skan 861169695Skan 862169695SkanWRAPPER2(size_t, fwrite, const void *ptr, size_t size, size_t nmemb, 863169695Skan FILE *stream) 864169695Skan{ 865169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 866169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 867169695Skan "fwrite stream"); 868169695Skan MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_READ, "fwrite buffer"); 869169695Skan return fwrite (ptr, size, nmemb, stream); 870169695Skan} 871169695Skan 872169695Skan 873169695SkanWRAPPER2(int, fgetc, FILE *stream) 874169695Skan{ 875169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 876169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 877169695Skan "fgetc stream"); 878169695Skan return fgetc (stream); 879169695Skan} 880169695Skan 881169695Skan 882169695SkanWRAPPER2(char *, fgets, char *s, int size, FILE *stream) 883169695Skan{ 884169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 885169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 886169695Skan "fgets stream"); 887169695Skan MF_VALIDATE_EXTENT (s, size, __MF_CHECK_WRITE, "fgets buffer"); 888169695Skan return fgets (s, size, stream); 889169695Skan} 890169695Skan 891169695Skan 892169695SkanWRAPPER2(int, getc, FILE *stream) 893169695Skan{ 894169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 895169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 896169695Skan "getc stream"); 897169695Skan return getc (stream); 898169695Skan} 899169695Skan 900169695Skan 901169695SkanWRAPPER2(char *, gets, char *s) 902169695Skan{ 903169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 904169695Skan MF_VALIDATE_EXTENT (s, 1, __MF_CHECK_WRITE, "gets buffer"); 905169695Skan /* Avoid link-time warning... */ 906169695Skan s = fgets (s, INT_MAX, stdin); 907169695Skan if (NULL != s) { /* better late than never */ 908169695Skan size_t n = strlen (s); 909169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_WRITE, "gets buffer"); 910169695Skan } 911169695Skan return s; 912169695Skan} 913169695Skan 914169695Skan 915169695SkanWRAPPER2(int, ungetc, int c, FILE *stream) 916169695Skan{ 917169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 918169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 919169695Skan "ungetc stream"); 920169695Skan return ungetc (c, stream); 921169695Skan} 922169695Skan 923169695Skan 924169695SkanWRAPPER2(int, fputc, int c, FILE *stream) 925169695Skan{ 926169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 927169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 928169695Skan "fputc stream"); 929169695Skan return fputc (c, stream); 930169695Skan} 931169695Skan 932169695Skan 933169695SkanWRAPPER2(int, fputs, const char *s, FILE *stream) 934169695Skan{ 935169695Skan size_t n; 936169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 937169695Skan n = strlen (s); 938169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "fputs buffer"); 939169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 940169695Skan "fputs stream"); 941169695Skan return fputs (s, stream); 942169695Skan} 943169695Skan 944169695Skan 945169695SkanWRAPPER2(int, putc, int c, FILE *stream) 946169695Skan{ 947169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 948169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 949169695Skan "putc stream"); 950169695Skan return putc (c, stream); 951169695Skan} 952169695Skan 953169695Skan 954169695SkanWRAPPER2(int, puts, const char *s) 955169695Skan{ 956169695Skan size_t n; 957169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 958169695Skan n = strlen (s); 959169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "puts buffer"); 960169695Skan return puts (s); 961169695Skan} 962169695Skan 963169695Skan 964169695SkanWRAPPER2(void, clearerr, FILE *stream) 965169695Skan{ 966169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 967169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 968169695Skan "clearerr stream"); 969169695Skan clearerr (stream); 970169695Skan} 971169695Skan 972169695Skan 973169695SkanWRAPPER2(int, feof, FILE *stream) 974169695Skan{ 975169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 976169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 977169695Skan "feof stream"); 978169695Skan return feof (stream); 979169695Skan} 980169695Skan 981169695Skan 982169695SkanWRAPPER2(int, ferror, FILE *stream) 983169695Skan{ 984169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 985169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 986169695Skan "ferror stream"); 987169695Skan return ferror (stream); 988169695Skan} 989169695Skan 990169695Skan 991169695SkanWRAPPER2(int, fileno, FILE *stream) 992169695Skan{ 993169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 994169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 995169695Skan "fileno stream"); 996169695Skan return fileno (stream); 997169695Skan} 998169695Skan 999169695Skan 1000169695SkanWRAPPER2(int, printf, const char *format, ...) 1001169695Skan{ 1002169695Skan size_t n; 1003169695Skan va_list ap; 1004169695Skan int result; 1005169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1006169695Skan n = strlen (format); 1007169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1008169695Skan "printf format"); 1009169695Skan va_start (ap, format); 1010169695Skan result = vprintf (format, ap); 1011169695Skan va_end (ap); 1012169695Skan return result; 1013169695Skan} 1014169695Skan 1015169695Skan 1016169695SkanWRAPPER2(int, fprintf, FILE *stream, const char *format, ...) 1017169695Skan{ 1018169695Skan size_t n; 1019169695Skan va_list ap; 1020169695Skan int result; 1021169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1022169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1023169695Skan "fprintf stream"); 1024169695Skan n = strlen (format); 1025169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1026169695Skan "fprintf format"); 1027169695Skan va_start (ap, format); 1028169695Skan result = vfprintf (stream, format, ap); 1029169695Skan va_end (ap); 1030169695Skan return result; 1031169695Skan} 1032169695Skan 1033169695Skan 1034169695SkanWRAPPER2(int, sprintf, char *str, const char *format, ...) 1035169695Skan{ 1036169695Skan size_t n; 1037169695Skan va_list ap; 1038169695Skan int result; 1039169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1040169695Skan MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "sprintf str"); 1041169695Skan n = strlen (format); 1042169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1043169695Skan "sprintf format"); 1044169695Skan va_start (ap, format); 1045169695Skan result = vsprintf (str, format, ap); 1046169695Skan va_end (ap); 1047169695Skan n = strlen (str); 1048169695Skan MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "sprintf str"); 1049169695Skan return result; 1050169695Skan} 1051169695Skan 1052169695Skan 1053169695SkanWRAPPER2(int, snprintf, char *str, size_t size, const char *format, ...) 1054169695Skan{ 1055169695Skan size_t n; 1056169695Skan va_list ap; 1057169695Skan int result; 1058169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1059169695Skan MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "snprintf str"); 1060169695Skan n = strlen (format); 1061169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1062169695Skan "snprintf format"); 1063169695Skan va_start (ap, format); 1064169695Skan result = vsnprintf (str, size, format, ap); 1065169695Skan va_end (ap); 1066169695Skan return result; 1067169695Skan} 1068169695Skan 1069169695Skan 1070169695SkanWRAPPER2(int, vprintf, const char *format, va_list ap) 1071169695Skan{ 1072169695Skan size_t n; 1073169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1074169695Skan n = strlen (format); 1075169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1076169695Skan "vprintf format"); 1077169695Skan return vprintf (format, ap); 1078169695Skan} 1079169695Skan 1080169695Skan 1081169695SkanWRAPPER2(int, vfprintf, FILE *stream, const char *format, va_list ap) 1082169695Skan{ 1083169695Skan size_t n; 1084169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1085169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1086169695Skan "vfprintf stream"); 1087169695Skan n = strlen (format); 1088169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1089169695Skan "vfprintf format"); 1090169695Skan return vfprintf (stream, format, ap); 1091169695Skan} 1092169695Skan 1093169695Skan 1094169695SkanWRAPPER2(int, vsprintf, char *str, const char *format, va_list ap) 1095169695Skan{ 1096169695Skan size_t n; 1097169695Skan int result; 1098169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1099169695Skan MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "vsprintf str"); 1100169695Skan n = strlen (format); 1101169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1102169695Skan "vsprintf format"); 1103169695Skan result = vsprintf (str, format, ap); 1104169695Skan n = strlen (str); 1105169695Skan MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "vsprintf str"); 1106169695Skan return result; 1107169695Skan} 1108169695Skan 1109169695Skan 1110169695SkanWRAPPER2(int, vsnprintf, char *str, size_t size, const char *format, 1111169695Skan va_list ap) 1112169695Skan{ 1113169695Skan size_t n; 1114169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1115169695Skan MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "vsnprintf str"); 1116169695Skan n = strlen (format); 1117169695Skan MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ, 1118169695Skan "vsnprintf format"); 1119169695Skan return vsnprintf (str, size, format, ap); 1120169695Skan} 1121169695Skan 1122169695Skan 1123169695SkanWRAPPER2(int , access, const char *path, int mode) 1124169695Skan{ 1125169695Skan size_t n; 1126169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1127169695Skan n = strlen (path); 1128169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "access path"); 1129169695Skan return access (path, mode); 1130169695Skan} 1131169695Skan 1132169695Skan 1133169695SkanWRAPPER2(int , remove, const char *path) 1134169695Skan{ 1135169695Skan size_t n; 1136169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1137169695Skan n = strlen (path); 1138169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "remove path"); 1139169695Skan return remove (path); 1140169695Skan} 1141169695Skan 1142169695Skan 1143169695SkanWRAPPER2(int, fflush, FILE *stream) 1144169695Skan{ 1145169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1146169695Skan if (stream != NULL) 1147169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1148169695Skan "fflush stream"); 1149169695Skan return fflush (stream); 1150169695Skan} 1151169695Skan 1152169695Skan 1153169695SkanWRAPPER2(int, fseek, FILE *stream, long offset, int whence) 1154169695Skan{ 1155169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1156169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1157169695Skan "fseek stream"); 1158169695Skan return fseek (stream, offset, whence); 1159169695Skan} 1160169695Skan 1161169695Skan 1162169695Skan#ifdef HAVE_FSEEKO64 1163169695SkanWRAPPER2(int, fseeko64, FILE *stream, off64_t offset, int whence) 1164169695Skan{ 1165169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1166169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1167169695Skan "fseeko64 stream"); 1168169695Skan return fseeko64 (stream, offset, whence); 1169169695Skan} 1170169695Skan#endif 1171169695Skan 1172169695Skan 1173169695SkanWRAPPER2(long, ftell, FILE *stream) 1174169695Skan{ 1175169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1176169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1177169695Skan "ftell stream"); 1178169695Skan return ftell (stream); 1179169695Skan} 1180169695Skan 1181169695Skan 1182169695Skan#ifdef HAVE_FTELLO64 1183169695SkanWRAPPER2(off64_t, ftello64, FILE *stream) 1184169695Skan{ 1185169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1186169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1187169695Skan "ftello64 stream"); 1188169695Skan return ftello64 (stream); 1189169695Skan} 1190169695Skan#endif 1191169695Skan 1192169695Skan 1193169695SkanWRAPPER2(void, rewind, FILE *stream) 1194169695Skan{ 1195169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1196169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1197169695Skan "rewind stream"); 1198169695Skan rewind (stream); 1199169695Skan} 1200169695Skan 1201169695Skan 1202169695SkanWRAPPER2(int, fgetpos, FILE *stream, fpos_t *pos) 1203169695Skan{ 1204169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1205169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1206169695Skan "fgetpos stream"); 1207169695Skan MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_WRITE, "fgetpos pos"); 1208169695Skan return fgetpos (stream, pos); 1209169695Skan} 1210169695Skan 1211169695Skan 1212169695SkanWRAPPER2(int, fsetpos, FILE *stream, fpos_t *pos) 1213169695Skan{ 1214169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1215169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1216169695Skan "fsetpos stream"); 1217169695Skan MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_READ, "fsetpos pos"); 1218169695Skan return fsetpos (stream, pos); 1219169695Skan} 1220169695Skan 1221169695Skan 1222169695SkanWRAPPER2(int , stat, const char *path, struct stat *buf) 1223169695Skan{ 1224169695Skan size_t n; 1225169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1226169695Skan n = strlen (path); 1227169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat path"); 1228169695Skan MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat buf"); 1229169695Skan return stat (path, buf); 1230169695Skan} 1231169695Skan 1232169695Skan 1233169695Skan#ifdef HAVE_STAT64 1234169695SkanWRAPPER2(int , stat64, const char *path, struct stat64 *buf) 1235169695Skan{ 1236169695Skan size_t n; 1237169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1238169695Skan n = strlen (path); 1239169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat64 path"); 1240169695Skan MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat64 buf"); 1241169695Skan return stat64 (path, buf); 1242169695Skan} 1243169695Skan#endif 1244169695Skan 1245169695Skan 1246169695SkanWRAPPER2(int , fstat, int filedes, struct stat *buf) 1247169695Skan{ 1248169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1249169695Skan MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "fstat buf"); 1250169695Skan return fstat (filedes, buf); 1251169695Skan} 1252169695Skan 1253169695Skan 1254169695SkanWRAPPER2(int , lstat, const char *path, struct stat *buf) 1255169695Skan{ 1256169695Skan size_t n; 1257169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1258169695Skan n = strlen (path); 1259169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "lstat path"); 1260169695Skan MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "lstat buf"); 1261169695Skan return lstat (path, buf); 1262169695Skan} 1263169695Skan 1264169695Skan 1265169695SkanWRAPPER2(int , mkfifo, const char *path, mode_t mode) 1266169695Skan{ 1267169695Skan size_t n; 1268169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1269169695Skan n = strlen (path); 1270169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "mkfifo path"); 1271169695Skan return mkfifo (path, mode); 1272169695Skan} 1273169695Skan 1274169695Skan 1275169695Skan#ifdef HAVE_DIRENT_H 1276169695SkanWRAPPER2(DIR *, opendir, const char *path) 1277169695Skan{ 1278169695Skan DIR *p; 1279169695Skan size_t n; 1280169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1281169695Skan n = strlen (path); 1282169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "opendir path"); 1283169695Skan 1284169695Skan p = opendir (path); 1285169695Skan if (NULL != p) { 1286169695Skan#ifdef MF_REGISTER_opendir 1287169695Skan __mf_register (p, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir, 1288169695Skan "opendir result"); 1289169695Skan#endif 1290169695Skan MF_VALIDATE_EXTENT (p, MF_RESULT_SIZE_opendir, __MF_CHECK_WRITE, 1291169695Skan "opendir result"); 1292169695Skan } 1293169695Skan return p; 1294169695Skan} 1295169695Skan 1296169695Skan 1297169695SkanWRAPPER2(int, closedir, DIR *dir) 1298169695Skan{ 1299169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1300169695Skan MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_WRITE, "closedir dir"); 1301169695Skan#ifdef MF_REGISTER_opendir 1302169695Skan __mf_unregister (dir, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir); 1303169695Skan#endif 1304169695Skan return closedir (dir); 1305169695Skan} 1306169695Skan 1307169695Skan 1308169695SkanWRAPPER2(struct dirent *, readdir, DIR *dir) 1309169695Skan{ 1310169695Skan struct dirent *p; 1311169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1312169695Skan MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_READ, "readdir dir"); 1313169695Skan p = readdir (dir); 1314169695Skan if (NULL != p) { 1315169695Skan#ifdef MF_REGISTER_readdir 1316169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_readdir, "readdir result"); 1317169695Skan#endif 1318169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "readdir result"); 1319169695Skan } 1320169695Skan return p; 1321169695Skan} 1322169695Skan#endif 1323169695Skan 1324169695Skan 1325169695Skan#ifdef HAVE_SYS_SOCKET_H 1326169695Skan 1327169695SkanWRAPPER2(int, recv, int s, void *buf, size_t len, int flags) 1328169695Skan{ 1329169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1330169695Skan MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recv buf"); 1331169695Skan return recv (s, buf, len, flags); 1332169695Skan} 1333169695Skan 1334169695Skan 1335169695SkanWRAPPER2(int, recvfrom, int s, void *buf, size_t len, int flags, 1336169695Skan struct sockaddr *from, socklen_t *fromlen) 1337169695Skan{ 1338169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1339169695Skan MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recvfrom buf"); 1340169695Skan MF_VALIDATE_EXTENT (from, (size_t)*fromlen, __MF_CHECK_WRITE, 1341169695Skan "recvfrom from"); 1342169695Skan return recvfrom (s, buf, len, flags, from, fromlen); 1343169695Skan} 1344169695Skan 1345169695Skan 1346169695SkanWRAPPER2(int, recvmsg, int s, struct msghdr *msg, int flags) 1347169695Skan{ 1348169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1349169695Skan MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_WRITE, "recvmsg msg"); 1350169695Skan return recvmsg (s, msg, flags); 1351169695Skan} 1352169695Skan 1353169695Skan 1354169695SkanWRAPPER2(int, send, int s, const void *msg, size_t len, int flags) 1355169695Skan{ 1356169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1357169695Skan MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "send msg"); 1358169695Skan return send (s, msg, len, flags); 1359169695Skan} 1360169695Skan 1361169695Skan 1362169695SkanWRAPPER2(int, sendto, int s, const void *msg, size_t len, int flags, 1363169695Skan const struct sockaddr *to, socklen_t tolen) 1364169695Skan{ 1365169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1366169695Skan MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "sendto msg"); 1367169695Skan MF_VALIDATE_EXTENT (to, (size_t)tolen, __MF_CHECK_WRITE, "sendto to"); 1368169695Skan return sendto (s, msg, len, flags, to, tolen); 1369169695Skan} 1370169695Skan 1371169695Skan 1372169695SkanWRAPPER2(int, sendmsg, int s, const void *msg, int flags) 1373169695Skan{ 1374169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1375169695Skan MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_READ, "sendmsg msg"); 1376169695Skan return sendmsg (s, msg, flags); 1377169695Skan} 1378169695Skan 1379169695Skan 1380169695SkanWRAPPER2(int, setsockopt, int s, int level, int optname, const void *optval, 1381169695Skan socklen_t optlen) 1382169695Skan{ 1383169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1384169695Skan MF_VALIDATE_EXTENT (optval, (size_t)optlen, __MF_CHECK_READ, 1385169695Skan "setsockopt optval"); 1386169695Skan return setsockopt (s, level, optname, optval, optlen); 1387169695Skan} 1388169695Skan 1389169695Skan 1390169695SkanWRAPPER2(int, getsockopt, int s, int level, int optname, void *optval, 1391169695Skan socklen_t *optlen) 1392169695Skan{ 1393169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1394169695Skan MF_VALIDATE_EXTENT (optval, (size_t)*optlen, __MF_CHECK_WRITE, 1395169695Skan "getsockopt optval"); 1396169695Skan return getsockopt (s, level, optname, optval, optlen); 1397169695Skan} 1398169695Skan 1399169695Skan 1400169695SkanWRAPPER2(int, accept, int s, struct sockaddr *addr, socklen_t *addrlen) 1401169695Skan{ 1402169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1403169695Skan if (addr != NULL) 1404169695Skan MF_VALIDATE_EXTENT (addr, (size_t)*addrlen, __MF_CHECK_WRITE, "accept addr"); 1405169695Skan return accept (s, addr, addrlen); 1406169695Skan} 1407169695Skan 1408169695Skan 1409169695SkanWRAPPER2(int, bind, int sockfd, struct sockaddr *addr, socklen_t addrlen) 1410169695Skan{ 1411169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1412169695Skan MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_WRITE, "bind addr"); 1413169695Skan return bind (sockfd, addr, addrlen); 1414169695Skan} 1415169695Skan 1416169695Skan 1417169695SkanWRAPPER2(int, connect, int sockfd, const struct sockaddr *addr, 1418169695Skan socklen_t addrlen) 1419169695Skan{ 1420169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1421169695Skan MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_READ, 1422169695Skan "connect addr"); 1423169695Skan return connect (sockfd, addr, addrlen); 1424169695Skan} 1425169695Skan 1426169695Skan#endif /* HAVE_SYS_SOCKET_H */ 1427169695Skan 1428169695Skan 1429169695SkanWRAPPER2(int, gethostname, char *name, size_t len) 1430169695Skan{ 1431169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1432169695Skan MF_VALIDATE_EXTENT (name, len, __MF_CHECK_WRITE, "gethostname name"); 1433169695Skan return gethostname (name, len); 1434169695Skan} 1435169695Skan 1436169695Skan 1437169695Skan#ifdef HAVE_SETHOSTNAME 1438169695SkanWRAPPER2(int, sethostname, const char *name, size_t len) 1439169695Skan{ 1440169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1441169695Skan MF_VALIDATE_EXTENT (name, len, __MF_CHECK_READ, "sethostname name"); 1442169695Skan return sethostname (name, len); 1443169695Skan} 1444169695Skan#endif 1445169695Skan 1446169695Skan 1447169695Skan#ifdef HAVE_NETDB_H 1448169695Skan 1449169695SkanWRAPPER2(struct hostent *, gethostbyname, const char *name) 1450169695Skan{ 1451169695Skan struct hostent *p; 1452169695Skan char **ss; 1453169695Skan char *s; 1454169695Skan size_t n; 1455169695Skan int nreg; 1456169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1457169695Skan n = strlen (name); 1458169695Skan MF_VALIDATE_EXTENT (name, CLAMPADD(n, 1), __MF_CHECK_READ, 1459169695Skan "gethostbyname name"); 1460169695Skan p = gethostbyname (name); 1461169695Skan if (NULL != p) { 1462169695Skan#ifdef MF_REGISTER_gethostbyname 1463169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_gethostbyname, 1464169695Skan "gethostbyname result"); 1465169695Skan#endif 1466169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, 1467169695Skan "gethostbyname result"); 1468169695Skan if (NULL != (s = p->h_name)) { 1469169695Skan n = strlen (s); 1470169695Skan n = CLAMPADD(n, 1); 1471169695Skan#ifdef MF_REGISTER_gethostbyname_items 1472169695Skan __mf_register (s, n, MF_REGISTER_gethostbyname_items, 1473169695Skan "gethostbyname result->h_name"); 1474169695Skan#endif 1475169695Skan MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE, 1476169695Skan "gethostbyname result->h_name"); 1477169695Skan } 1478169695Skan 1479169695Skan if (NULL != (ss = p->h_aliases)) { 1480169695Skan for (nreg = 1;; ++nreg) { 1481169695Skan s = *ss++; 1482169695Skan if (NULL == s) 1483169695Skan break; 1484169695Skan n = strlen (s); 1485169695Skan n = CLAMPADD(n, 1); 1486169695Skan#ifdef MF_REGISTER_gethostbyname_items 1487169695Skan __mf_register (s, n, MF_REGISTER_gethostbyname_items, 1488169695Skan "gethostbyname result->h_aliases[]"); 1489169695Skan#endif 1490169695Skan MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE, 1491169695Skan "gethostbyname result->h_aliases[]"); 1492169695Skan } 1493169695Skan nreg *= sizeof (*p->h_aliases); 1494169695Skan#ifdef MF_REGISTER_gethostbyname_items 1495169695Skan __mf_register (p->h_aliases, nreg, MF_REGISTER_gethostbyname_items, 1496169695Skan "gethostbyname result->h_aliases"); 1497169695Skan#endif 1498169695Skan MF_VALIDATE_EXTENT (p->h_aliases, nreg, __MF_CHECK_WRITE, 1499169695Skan "gethostbyname result->h_aliases"); 1500169695Skan } 1501169695Skan 1502169695Skan if (NULL != (ss = p->h_addr_list)) { 1503169695Skan for (nreg = 1;; ++nreg) { 1504169695Skan s = *ss++; 1505169695Skan if (NULL == s) 1506169695Skan break; 1507169695Skan#ifdef MF_REGISTER_gethostbyname_items 1508169695Skan __mf_register (s, p->h_length, MF_REGISTER_gethostbyname_items, 1509169695Skan "gethostbyname result->h_addr_list[]"); 1510169695Skan#endif 1511169695Skan MF_VALIDATE_EXTENT (s, p->h_length, __MF_CHECK_WRITE, 1512169695Skan "gethostbyname result->h_addr_list[]"); 1513169695Skan } 1514169695Skan nreg *= sizeof (*p->h_addr_list); 1515169695Skan#ifdef MF_REGISTER_gethostbyname_items 1516169695Skan __mf_register (p->h_addr_list, nreg, MF_REGISTER_gethostbyname_items, 1517169695Skan "gethostbyname result->h_addr_list"); 1518169695Skan#endif 1519169695Skan MF_VALIDATE_EXTENT (p->h_addr_list, nreg, __MF_CHECK_WRITE, 1520169695Skan "gethostbyname result->h_addr_list"); 1521169695Skan } 1522169695Skan } 1523169695Skan return p; 1524169695Skan} 1525169695Skan 1526169695Skan#endif /* HAVE_NETDB_H */ 1527169695Skan 1528169695Skan 1529169695Skan#ifdef HAVE_SYS_WAIT_H 1530169695Skan 1531169695SkanWRAPPER2(pid_t, wait, int *status) 1532169695Skan{ 1533169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1534169695Skan if (NULL != status) 1535169695Skan MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE, 1536169695Skan "wait status"); 1537169695Skan return wait (status); 1538169695Skan} 1539169695Skan 1540169695Skan 1541169695SkanWRAPPER2(pid_t, waitpid, pid_t pid, int *status, int options) 1542169695Skan{ 1543169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1544169695Skan if (NULL != status) 1545169695Skan MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE, 1546169695Skan "waitpid status"); 1547169695Skan return waitpid (pid, status, options); 1548169695Skan} 1549169695Skan 1550169695Skan#endif /* HAVE_SYS_WAIT_H */ 1551169695Skan 1552169695Skan 1553169695SkanWRAPPER2(FILE *, popen, const char *command, const char *mode) 1554169695Skan{ 1555169695Skan size_t n; 1556169695Skan FILE *p; 1557169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1558169695Skan 1559169695Skan n = strlen (command); 1560169695Skan MF_VALIDATE_EXTENT (command, CLAMPADD(n, 1), __MF_CHECK_READ, "popen path"); 1561169695Skan 1562169695Skan n = strlen (mode); 1563169695Skan MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "popen mode"); 1564169695Skan 1565169695Skan p = popen (command, mode); 1566169695Skan if (NULL != p) { 1567169695Skan#ifdef MF_REGISTER_fopen 1568169695Skan __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "popen result"); 1569169695Skan#endif 1570169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "popen result"); 1571169695Skan } 1572169695Skan return p; 1573169695Skan} 1574169695Skan 1575169695Skan 1576169695SkanWRAPPER2(int, pclose, FILE *stream) 1577169695Skan{ 1578169695Skan int resp; 1579169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1580169695Skan MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, 1581169695Skan "pclose stream"); 1582169695Skan resp = pclose (stream); 1583169695Skan#ifdef MF_REGISTER_fopen 1584169695Skan __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen); 1585169695Skan#endif 1586169695Skan return resp; 1587169695Skan} 1588169695Skan 1589169695Skan 1590169695SkanWRAPPER2(int, execve, const char *path, char *const argv [], 1591169695Skan char *const envp[]) 1592169695Skan{ 1593169695Skan size_t n; 1594169695Skan char *const *p; 1595169695Skan const char *s; 1596169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1597169695Skan 1598169695Skan n = strlen (path); 1599169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execve path"); 1600169695Skan 1601169695Skan for (p = argv;;) { 1602169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *argv"); 1603169695Skan s = *p++; 1604169695Skan if (NULL == s) 1605169695Skan break; 1606169695Skan n = strlen (s); 1607169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **argv"); 1608169695Skan } 1609169695Skan 1610169695Skan for (p = envp;;) { 1611169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *envp"); 1612169695Skan s = *p++; 1613169695Skan if (NULL == s) 1614169695Skan break; 1615169695Skan n = strlen (s); 1616169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **envp"); 1617169695Skan } 1618169695Skan return execve (path, argv, envp); 1619169695Skan} 1620169695Skan 1621169695Skan 1622169695SkanWRAPPER2(int, execv, const char *path, char *const argv []) 1623169695Skan{ 1624169695Skan size_t n; 1625169695Skan char *const *p; 1626169695Skan const char *s; 1627169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1628169695Skan 1629169695Skan n = strlen (path); 1630169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execv path"); 1631169695Skan 1632169695Skan for (p = argv;;) { 1633169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execv *argv"); 1634169695Skan s = *p++; 1635169695Skan if (NULL == s) 1636169695Skan break; 1637169695Skan n = strlen (s); 1638169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execv **argv"); 1639169695Skan } 1640169695Skan return execv (path, argv); 1641169695Skan} 1642169695Skan 1643169695Skan 1644169695SkanWRAPPER2(int, execvp, const char *path, char *const argv []) 1645169695Skan{ 1646169695Skan size_t n; 1647169695Skan char *const *p; 1648169695Skan const char *s; 1649169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1650169695Skan 1651169695Skan n = strlen (path); 1652169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp path"); 1653169695Skan 1654169695Skan for (p = argv;;) { 1655169695Skan MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execvp *argv"); 1656169695Skan s = *p++; 1657169695Skan if (NULL == s) 1658169695Skan break; 1659169695Skan n = strlen (s); 1660169695Skan MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp **argv"); 1661169695Skan } 1662169695Skan return execvp (path, argv); 1663169695Skan} 1664169695Skan 1665169695Skan 1666169695SkanWRAPPER2(int, system, const char *string) 1667169695Skan{ 1668169695Skan size_t n; 1669169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1670169695Skan n = strlen (string); 1671169695Skan MF_VALIDATE_EXTENT (string, CLAMPADD(n, 1), __MF_CHECK_READ, 1672169695Skan "system string"); 1673169695Skan return system (string); 1674169695Skan} 1675169695Skan 1676169695Skan 1677169695SkanWRAPPER2(void *, dlopen, const char *path, int flags) 1678169695Skan{ 1679169695Skan void *p; 1680169695Skan size_t n; 1681169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1682169695Skan n = strlen (path); 1683169695Skan MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "dlopen path"); 1684169695Skan p = dlopen (path, flags); 1685169695Skan if (NULL != p) { 1686169695Skan#ifdef MF_REGISTER_dlopen 1687169695Skan __mf_register (p, 0, MF_REGISTER_dlopen, "dlopen result"); 1688169695Skan#endif 1689169695Skan MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlopen result"); 1690169695Skan } 1691169695Skan return p; 1692169695Skan} 1693169695Skan 1694169695Skan 1695169695SkanWRAPPER2(int, dlclose, void *handle) 1696169695Skan{ 1697169695Skan int resp; 1698169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1699169695Skan MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlclose handle"); 1700169695Skan resp = dlclose (handle); 1701169695Skan#ifdef MF_REGISTER_dlopen 1702169695Skan __mf_unregister (handle, 0, MF_REGISTER_dlopen); 1703169695Skan#endif 1704169695Skan return resp; 1705169695Skan} 1706169695Skan 1707169695Skan 1708169695SkanWRAPPER2(char *, dlerror) 1709169695Skan{ 1710169695Skan char *p; 1711169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1712169695Skan p = dlerror (); 1713169695Skan if (NULL != p) { 1714169695Skan size_t n; 1715169695Skan n = strlen (p); 1716169695Skan n = CLAMPADD(n, 1); 1717169695Skan#ifdef MF_REGISTER_dlerror 1718169695Skan __mf_register (p, n, MF_REGISTER_dlerror, "dlerror result"); 1719169695Skan#endif 1720169695Skan MF_VALIDATE_EXTENT (p, n, __MF_CHECK_WRITE, "dlerror result"); 1721169695Skan } 1722169695Skan return p; 1723169695Skan} 1724169695Skan 1725169695Skan 1726169695SkanWRAPPER2(void *, dlsym, void *handle, char *symbol) 1727169695Skan{ 1728169695Skan size_t n; 1729169695Skan void *p; 1730169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1731169695Skan MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlsym handle"); 1732169695Skan n = strlen (symbol); 1733169695Skan MF_VALIDATE_EXTENT (symbol, CLAMPADD(n, 1), __MF_CHECK_READ, "dlsym symbol"); 1734169695Skan p = dlsym (handle, symbol); 1735169695Skan if (NULL != p) { 1736169695Skan#ifdef MF_REGISTER_dlsym 1737169695Skan __mf_register (p, 0, MF_REGISTER_dlsym, "dlsym result"); 1738169695Skan#endif 1739169695Skan MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlsym result"); 1740169695Skan } 1741169695Skan return p; 1742169695Skan} 1743169695Skan 1744169695Skan 1745169695Skan#if defined (HAVE_SYS_IPC_H) && defined (HAVE_SYS_SEM_H) && defined (HAVE_SYS_SHM_H) 1746169695Skan 1747169695SkanWRAPPER2(int, semop, int semid, struct sembuf *sops, unsigned nsops) 1748169695Skan{ 1749169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1750169695Skan MF_VALIDATE_EXTENT (sops, sizeof (*sops) * nsops, __MF_CHECK_READ, 1751169695Skan "semop sops"); 1752169695Skan return semop (semid, sops, nsops); 1753169695Skan} 1754169695Skan 1755169695Skan 1756169695Skan#ifndef HAVE_UNION_SEMUN 1757169695Skanunion semun { 1758169695Skan int val; /* value for SETVAL */ 1759169695Skan struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */ 1760169695Skan unsigned short int *array; /* array for GETALL, SETALL */ 1761169695Skan struct seminfo *__buf; /* buffer for IPC_INFO */ 1762169695Skan}; 1763169695Skan#endif 1764169695SkanWRAPPER2(int, semctl, int semid, int semnum, int cmd, union semun arg) 1765169695Skan{ 1766169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1767169695Skan switch (cmd) { 1768169695Skan case IPC_STAT: 1769169695Skan MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_WRITE, 1770169695Skan "semctl buf"); 1771169695Skan break; 1772169695Skan case IPC_SET: 1773169695Skan MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_READ, 1774169695Skan "semctl buf"); 1775169695Skan break; 1776169695Skan case GETALL: 1777169695Skan MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_WRITE, 1778169695Skan "semctl array"); 1779169695Skan case SETALL: 1780169695Skan MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_READ, 1781169695Skan "semctl array"); 1782169695Skan break; 1783169695Skan#ifdef IPC_INFO 1784169695Skan /* FreeBSD 5.1 And Cygwin headers include IPC_INFO but not the __buf field. */ 1785169695Skan#if !defined(__FreeBSD__) && !defined(__CYGWIN__) 1786169695Skan case IPC_INFO: 1787169695Skan MF_VALIDATE_EXTENT (arg.__buf, sizeof (*arg.__buf), __MF_CHECK_WRITE, 1788169695Skan "semctl __buf"); 1789169695Skan break; 1790169695Skan#endif 1791169695Skan#endif 1792169695Skan default: 1793169695Skan break; 1794169695Skan } 1795169695Skan return semctl (semid, semnum, cmd, arg); 1796169695Skan} 1797169695Skan 1798169695Skan 1799169695SkanWRAPPER2(int, shmctl, int shmid, int cmd, struct shmid_ds *buf) 1800169695Skan{ 1801169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1802169695Skan switch (cmd) { 1803169695Skan case IPC_STAT: 1804169695Skan MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_WRITE, 1805169695Skan "shmctl buf"); 1806169695Skan break; 1807169695Skan case IPC_SET: 1808169695Skan MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, 1809169695Skan "shmctl buf"); 1810169695Skan break; 1811169695Skan default: 1812169695Skan break; 1813169695Skan } 1814169695Skan return shmctl (shmid, cmd, buf); 1815169695Skan} 1816169695Skan 1817169695Skan 1818169695SkanWRAPPER2(void *, shmat, int shmid, const void *shmaddr, int shmflg) 1819169695Skan{ 1820169695Skan void *p; 1821169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1822169695Skan p = shmat (shmid, shmaddr, shmflg); 1823169695Skan#ifdef MF_REGISTER_shmat 1824169695Skan if (NULL != p) { 1825169695Skan struct shmid_ds buf; 1826169695Skan __mf_register (p, shmctl (shmid, IPC_STAT, &buf) ? 0 : buf.shm_segsz, 1827169695Skan MF_REGISTER_shmat, "shmat result"); 1828169695Skan } 1829169695Skan#endif 1830169695Skan return p; 1831169695Skan} 1832169695Skan 1833169695Skan 1834169695SkanWRAPPER2(int, shmdt, const void *shmaddr) 1835169695Skan{ 1836169695Skan int resp; 1837169695Skan TRACE ("%s\n", __PRETTY_FUNCTION__); 1838169695Skan resp = shmdt (shmaddr); 1839169695Skan#ifdef MF_REGISTER_shmat 1840169695Skan __mf_unregister ((void *)shmaddr, 0, MF_REGISTER_shmat); 1841169695Skan#endif 1842169695Skan return resp; 1843169695Skan} 1844169695Skan 1845169695Skan 1846169695Skan#endif /* HAVE_SYS_IPC/SEM/SHM_H */ 1847169695Skan 1848169695Skan 1849169695Skan 1850169695Skan/* ctype stuff. This is host-specific by necessity, as the arrays 1851169695Skan that is used by most is*()/to*() macros are implementation-defined. */ 1852169695Skan 1853169695Skan/* GLIBC 2.3 */ 1854169695Skan#ifdef HAVE___CTYPE_B_LOC 1855169695SkanWRAPPER2(unsigned short **, __ctype_b_loc, void) 1856169695Skan{ 1857169695Skan static unsigned short * last_buf = (void *) 0; 1858169695Skan static unsigned short ** last_ptr = (void *) 0; 1859169695Skan unsigned short ** ptr = (unsigned short **) __ctype_b_loc (); 1860169695Skan unsigned short * buf = * ptr; 1861169695Skan if (ptr != last_ptr) 1862169695Skan { 1863169695Skan /* XXX: unregister last_ptr? */ 1864169695Skan last_ptr = ptr; 1865169695Skan __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_b_loc **"); 1866169695Skan } 1867169695Skan if (buf != last_buf) 1868169695Skan { 1869169695Skan last_buf = buf; 1870169695Skan __mf_register ((void *) (last_buf - 128), 384 * sizeof(unsigned short), __MF_TYPE_STATIC, 1871169695Skan "ctype_b_loc []"); 1872169695Skan } 1873169695Skan return ptr; 1874169695Skan} 1875169695Skan#endif 1876169695Skan 1877169695Skan#ifdef HAVE___CTYPE_TOUPPER_LOC 1878169695SkanWRAPPER2(int **, __ctype_toupper_loc, void) 1879169695Skan{ 1880169695Skan static int * last_buf = (void *) 0; 1881169695Skan static int ** last_ptr = (void *) 0; 1882169695Skan int ** ptr = (int **) __ctype_toupper_loc (); 1883169695Skan int * buf = * ptr; 1884169695Skan if (ptr != last_ptr) 1885169695Skan { 1886169695Skan /* XXX: unregister last_ptr? */ 1887169695Skan last_ptr = ptr; 1888169695Skan __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_toupper_loc **"); 1889169695Skan } 1890169695Skan if (buf != last_buf) 1891169695Skan { 1892169695Skan last_buf = buf; 1893169695Skan __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC, 1894169695Skan "ctype_toupper_loc []"); 1895169695Skan } 1896169695Skan return ptr; 1897169695Skan} 1898169695Skan#endif 1899169695Skan 1900169695Skan#ifdef HAVE___CTYPE_TOLOWER_LOC 1901169695SkanWRAPPER2(int **, __ctype_tolower_loc, void) 1902169695Skan{ 1903169695Skan static int * last_buf = (void *) 0; 1904169695Skan static int ** last_ptr = (void *) 0; 1905169695Skan int ** ptr = (int **) __ctype_tolower_loc (); 1906169695Skan int * buf = * ptr; 1907169695Skan if (ptr != last_ptr) 1908169695Skan { 1909169695Skan /* XXX: unregister last_ptr? */ 1910169695Skan last_ptr = ptr; 1911169695Skan __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_tolower_loc **"); 1912169695Skan } 1913169695Skan if (buf != last_buf) 1914169695Skan { 1915169695Skan last_buf = buf; 1916169695Skan __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC, 1917169695Skan "ctype_tolower_loc []"); 1918169695Skan } 1919169695Skan return ptr; 1920169695Skan} 1921169695Skan#endif 1922169695Skan 1923169695Skan 1924169695Skan/* passwd/group related functions. These register every (static) pointer value returned, 1925169695Skan and rely on libmudflap's quiet toleration of duplicate static registrations. */ 1926169695Skan 1927169695Skan#ifdef HAVE_GETLOGIN 1928169695SkanWRAPPER2(char *, getlogin, void) 1929169695Skan{ 1930169695Skan char *buf = getlogin (); 1931169695Skan if (buf != NULL) 1932169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 1933169695Skan "getlogin() return"); 1934169695Skan return buf; 1935169695Skan} 1936169695Skan#endif 1937169695Skan 1938169695Skan 1939169695Skan#ifdef HAVE_CUSERID 1940169695SkanWRAPPER2(char *, cuserid, char * buf) 1941169695Skan{ 1942169695Skan if (buf != NULL) 1943169695Skan { 1944169695Skan MF_VALIDATE_EXTENT(buf, L_cuserid, __MF_CHECK_WRITE, 1945169695Skan "cuserid destination"); 1946169695Skan return cuserid (buf); 1947169695Skan } 1948169695Skan buf = cuserid (NULL); 1949169695Skan if (buf != NULL) 1950169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 1951169695Skan "getcuserid() return"); 1952169695Skan return buf; 1953169695Skan} 1954169695Skan#endif 1955169695Skan 1956169695Skan 1957169695Skan#ifdef HAVE_GETPWNAM 1958169695SkanWRAPPER2(struct passwd *, getpwnam, const char *name) 1959169695Skan{ 1960169695Skan struct passwd *buf; 1961169695Skan MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ, 1962169695Skan "getpwnam name"); 1963169695Skan buf = getpwnam (name); 1964169695Skan if (buf != NULL) 1965169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 1966169695Skan "getpw*() return"); 1967169695Skan return buf; 1968169695Skan} 1969169695Skan#endif 1970169695Skan 1971169695Skan 1972169695Skan#ifdef HAVE_GETPWUID 1973169695SkanWRAPPER2(struct passwd *, getpwuid, uid_t uid) 1974169695Skan{ 1975169695Skan struct passwd *buf; 1976169695Skan buf = getpwuid (uid); 1977169695Skan if (buf != NULL) 1978169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 1979169695Skan "getpw*() return"); 1980169695Skan return buf; 1981169695Skan} 1982169695Skan#endif 1983169695Skan 1984169695Skan 1985169695Skan#ifdef HAVE_GETGRNAM 1986169695SkanWRAPPER2(struct group *, getgrnam, const char *name) 1987169695Skan{ 1988169695Skan struct group *buf; 1989169695Skan MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ, 1990169695Skan "getgrnam name"); 1991169695Skan buf = getgrnam (name); 1992169695Skan if (buf != NULL) 1993169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 1994169695Skan "getgr*() return"); 1995169695Skan return buf; 1996169695Skan} 1997169695Skan#endif 1998169695Skan 1999169695Skan 2000169695Skan#ifdef HAVE_GETGRGID 2001169695SkanWRAPPER2(struct group *, getgrgid, uid_t uid) 2002169695Skan{ 2003169695Skan struct group *buf; 2004169695Skan buf = getgrgid (uid); 2005169695Skan if (buf != NULL) 2006169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 2007169695Skan "getgr*() return"); 2008169695Skan return buf; 2009169695Skan} 2010169695Skan#endif 2011169695Skan 2012169695Skan 2013169695Skan#ifdef HAVE_GETSERVENT 2014169695SkanWRAPPER2(struct servent *, getservent, void) 2015169695Skan{ 2016169695Skan struct servent *buf; 2017169695Skan buf = getservent (); 2018169695Skan if (buf != NULL) 2019169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 2020169695Skan "getserv*() return"); 2021169695Skan return buf; 2022169695Skan} 2023169695Skan#endif 2024169695Skan 2025169695Skan 2026169695Skan#ifdef HAVE_GETSERVBYNAME 2027169695SkanWRAPPER2(struct servent *, getservbyname, const char *name, const char *proto) 2028169695Skan{ 2029169695Skan struct servent *buf; 2030169695Skan MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ, 2031169695Skan "getservbyname name"); 2032169695Skan MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ, 2033169695Skan "getservbyname proto"); 2034169695Skan buf = getservbyname (name, proto); 2035169695Skan if (buf != NULL) 2036169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 2037169695Skan "getserv*() return"); 2038169695Skan return buf; 2039169695Skan} 2040169695Skan#endif 2041169695Skan 2042169695Skan 2043169695Skan#ifdef HAVE_GETSERVBYPORT 2044169695SkanWRAPPER2(struct servent *, getservbyport, int port, const char *proto) 2045169695Skan{ 2046169695Skan struct servent *buf; 2047169695Skan MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ, 2048169695Skan "getservbyport proto"); 2049169695Skan buf = getservbyport (port, proto); 2050169695Skan if (buf != NULL) 2051169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 2052169695Skan "getserv*() return"); 2053169695Skan return buf; 2054169695Skan} 2055169695Skan#endif 2056169695Skan 2057169695Skan 2058169695Skan#ifdef HAVE_GAI_STRERROR 2059169695SkanWRAPPER2(const char *, gai_strerror, int errcode) 2060169695Skan{ 2061169695Skan const char *buf; 2062169695Skan buf = gai_strerror (errcode); 2063169695Skan if (buf != NULL) 2064169695Skan __mf_register ((void *) buf, strlen(buf)+1, __MF_TYPE_STATIC, 2065169695Skan "gai_strerror() return"); 2066169695Skan return buf; 2067169695Skan} 2068169695Skan#endif 2069169695Skan 2070169695Skan 2071169695Skan#ifdef HAVE_GETMNTENT 2072169695SkanWRAPPER2(struct mntent *, getmntent, FILE *filep) 2073169695Skan{ 2074169695Skan struct mntent *m; 2075169695Skan static struct mntent *last = NULL; 2076169695Skan 2077169695Skan MF_VALIDATE_EXTENT (filep, sizeof (*filep), __MF_CHECK_WRITE, 2078169695Skan "getmntent stream"); 2079169695Skan#define UR(field) __mf_unregister(last->field, strlen (last->field)+1, __MF_TYPE_STATIC) 2080169695Skan if (last) 2081169695Skan { 2082169695Skan UR (mnt_fsname); 2083169695Skan UR (mnt_dir); 2084169695Skan UR (mnt_type); 2085169695Skan UR (mnt_opts); 2086169695Skan __mf_unregister (last, sizeof (*last), __MF_TYPE_STATIC); 2087169695Skan } 2088169695Skan#undef UR 2089169695Skan 2090169695Skan m = getmntent (filep); 2091169695Skan last = m; 2092169695Skan 2093169695Skan#define R(field) __mf_register(last->field, strlen (last->field)+1, __MF_TYPE_STATIC, "mntent " #field) 2094169695Skan if (m) 2095169695Skan { 2096169695Skan R (mnt_fsname); 2097169695Skan R (mnt_dir); 2098169695Skan R (mnt_type); 2099169695Skan R (mnt_opts); 2100169695Skan __mf_register (last, sizeof (*last), __MF_TYPE_STATIC, "getmntent result"); 2101169695Skan } 2102169695Skan#undef R 2103169695Skan 2104169695Skan return m; 2105169695Skan} 2106169695Skan#endif 2107169695Skan 2108169695Skan 2109169695Skan#ifdef HAVE_INET_NTOA 2110169695SkanWRAPPER2(char *, inet_ntoa, struct in_addr in) 2111169695Skan{ 2112169695Skan static char *last_buf = NULL; 2113169695Skan char *buf; 2114169695Skan if (last_buf) 2115169695Skan __mf_unregister (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC); 2116169695Skan buf = inet_ntoa (in); 2117169695Skan last_buf = buf; 2118169695Skan if (buf) 2119169695Skan __mf_register (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC, "inet_ntoa result"); 2120169695Skan return buf; 2121169695Skan} 2122169695Skan#endif 2123169695Skan 2124169695Skan 2125169695Skan#ifdef HAVE_GETPROTOENT 2126169695SkanWRAPPER2(struct protoent *, getprotoent, void) 2127169695Skan{ 2128169695Skan struct protoent *buf; 2129169695Skan buf = getprotoent (); 2130169695Skan if (buf != NULL) 2131169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, "getproto*() return"); 2132169695Skan return buf; 2133169695Skan} 2134169695Skan#endif 2135169695Skan 2136169695Skan 2137169695Skan#ifdef HAVE_GETPROTOBYNAME 2138169695SkanWRAPPER2(struct protoent *, getprotobyname, const char *name) 2139169695Skan{ 2140169695Skan struct protoent *buf; 2141169695Skan MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ, 2142169695Skan "getprotobyname name"); 2143169695Skan buf = getprotobyname (name); 2144169695Skan if (buf != NULL) 2145169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 2146169695Skan "getproto*() return"); 2147169695Skan return buf; 2148169695Skan} 2149169695Skan#endif 2150169695Skan 2151169695Skan 2152169695Skan#ifdef HAVE_GETPROTOBYNUMBER 2153169695SkanWRAPPER2(struct protoent *, getprotobynumber, int port) 2154169695Skan{ 2155169695Skan struct protoent *buf; 2156169695Skan buf = getprotobynumber (port); 2157169695Skan if (buf != NULL) 2158169695Skan __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, 2159169695Skan "getproto*() return"); 2160169695Skan return buf; 2161169695Skan} 2162169695Skan#endif 2163