Changeset 1639


Ignore:
Timestamp:
Jan 10, 2007, 3:57:22 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Split load-fd.c into load-fd.c and load-mem.c (mmap, etc.).
Location:
zzuf/trunk/src
Files:
4 edited
1 copied

Legend:

Unmodified
Added
Removed
  • zzuf/trunk/src/Makefile.am

    r1623 r1639  
    77pkglib_LTLIBRARIES = libzzuf.la
    88libzzuf_la_SOURCES = libzzuf.c libzzuf.h $(COMMON) debug.c debug.h \
    9                      load-fd.c load-signal.c load-stream.c load.h
     9                     load-fd.c load-mem.c load-signal.c load-stream.c load.h
    1010libzzuf_la_LDFLAGS = -avoid-version -no-undefined
    1111libzzuf_la_LIBADD = @GETOPT_LIBS@ @DL_LIBS@
  • zzuf/trunk/src/libzzuf.c

    r1621 r1639  
    9595
    9696    _zz_load_fd();
     97    _zz_load_mem();
    9798    _zz_load_signal();
    9899    _zz_load_stream();
  • zzuf/trunk/src/load-fd.c

    r1638 r1639  
    1919#include "config.h"
    2020
    21 /* Can't remember what that's for */
     21/* Need this for RTLD_NEXT */
    2222#define _GNU_SOURCE
    2323/* Use this to get lseek64() on glibc systems */
     
    3535#include <sys/types.h>
    3636#include <sys/socket.h>
    37 #include <sys/mman.h>
    3837#include <unistd.h>
    3938#include <fcntl.h>
    4039#include <stdarg.h>
    41 #if defined HAVE_LIBC_H
    42 #   include <libc.h>
    43 #endif
    4440
    4541#include "libzzuf.h"
     
    6864static off64_t (*lseek64_orig) (int fd, off64_t offset, int whence);
    6965#endif
    70 static void *  (*mmap_orig)    (void *start, size_t length, int prot,
    71                                 int flags, int fd, off_t offset);
    72 #ifdef HAVE_LSEEK64
    73 static void *  (*mmap64_orig)  (void *start, size_t length, int prot,
    74                                 int flags, int fd, off64_t offset);
    75 #endif
    76 static int     (*munmap_orig)  (void *start, size_t length);
    77 #ifdef HAVE_MAP_FD
    78 static kern_return_t (*map_fd_orig) (int fd, vm_offset_t offset,
    79                                      vm_offset_t *addr, boolean_t find_space,
    80                                      vm_size_t numbytes);
    81 #endif
    8266static int     (*close_orig)   (int fd);
    8367
     
    9579#ifdef HAVE_LSEEK64
    9680    LOADSYM(lseek64);
    97 #endif
    98     LOADSYM(mmap);
    99 #ifdef HAVE_MMAP64
    100     LOADSYM(mmap64);
    101 #endif
    102     LOADSYM(munmap);
    103 #ifdef HAVE_MAP_FD
    104     LOADSYM(map_fd);
    10581#endif
    10682    LOADSYM(close);
     
    258234#endif
    259235
    260 /* Used for mmap() and munmap() */
    261 void **maps = NULL;
    262 int nbmaps = 0;
    263 
    264 #define MMAP(fn, off_t) \
    265     do { \
    266         if(!_zz_ready) \
    267             LOADSYM(fn); \
    268         ret = ORIG(fn)(start, length, prot, flags, fd, offset); \
    269         if(!_zz_ready || !_zz_iswatched(fd) || _zz_disabled) \
    270             return ret; \
    271         if(ret && length) \
    272         { \
    273             char *b = malloc(length); \
    274             int i, oldpos; \
    275             for(i = 0; i < nbmaps; i += 2) \
    276                 if(maps[i] == NULL) \
    277                     break; \
    278             if(i == nbmaps) \
    279             { \
    280                 nbmaps += 2; \
    281                 maps = realloc(maps, nbmaps * sizeof(void *)); \
    282             } \
    283             maps[i] = b; \
    284             maps[i + 1] = ret; \
    285             oldpos = _zz_getpos(fd); \
    286             _zz_setpos(fd, offset); /* mmap() maps the fd at offset 0 */ \
    287             memcpy(b, ret, length); /* FIXME: get rid of this */ \
    288             _zz_fuzz(fd, (uint8_t *)b, length); \
    289             _zz_setpos(fd, oldpos); \
    290             ret = b; \
    291             if(length >= 4) \
    292                 debug(STR(fn)"(%p, %li, %i, %i, %i, %lli) = %p \"%c%c%c%c...", \
    293                       start, (long int)length, prot, flags, fd, \
    294                       (long long int)offset, ret, b[0], b[1], b[2], b[3]); \
    295             else \
    296                 debug(STR(fn)"(%p, %li, %i, %i, %i, %lli) = %p \"%c...", \
    297                       start, (long int)length, prot, flags, fd, \
    298                       (long long int)offset, ret, b[0]); \
    299         } \
    300         else \
    301             debug(STR(fn)"(%p, %li, %i, %i, %i, %lli) = %p", \
    302                   start, (long int)length, prot, flags, fd, \
    303                   (long long int)offset, ret); \
    304     } while(0)
    305 
    306 void *mmap(void *start, size_t length, int prot, int flags,
    307            int fd, off_t offset)
    308 {
    309     void *ret; MMAP(mmap, off_t); return ret;
    310 }
    311 
    312 #ifdef HAVE_MMAP64
    313 void *mmap64(void *start, size_t length, int prot, int flags,
    314              int fd, off64_t offset)
    315 {
    316     void *ret; MMAP(mmap64, off64_t); return ret;
    317 }
    318 #endif
    319 
    320 int munmap(void *start, size_t length)
    321 {
    322     int ret, i;
    323 
    324     if(!_zz_ready)
    325         LOADSYM(munmap);
    326     for(i = 0; i < nbmaps; i++)
    327     {
    328         if(maps[i] != start)
    329             continue;
    330 
    331         free(start);
    332         ret = munmap_orig(maps[i + 1], length);
    333         maps[i] = NULL;
    334         maps[i + 1] = NULL;
    335         debug("munmap(%p, %li) = %i", start, (long int)length, ret);
    336         return ret;
    337     }
    338 
    339     return munmap_orig(start, length);
    340 }
    341 
    342 #ifdef HAVE_MAP_FD
    343 kern_return_t map_fd(int fd, vm_offset_t offset, vm_offset_t *addr,
    344                      boolean_t find_space, vm_size_t numbytes)
    345 {
    346     kern_return_t ret;
    347 
    348     if(!_zz_ready)
    349         LOADSYM(map_fd);
    350     ret = map_fd_orig(fd, offset, addr, find_space, numbytes);
    351     if(!_zz_ready || !_zz_iswatched(fd) || _zz_disabled)
    352         return ret;
    353 
    354     if(ret == 0 && numbytes)
    355     {
    356         /* FIXME: do we also have to rewind the filedescriptor like in mmap? */
    357         void *b = malloc(numbytes);
    358         memcpy(b, (void *)*addr, numbytes);
    359         _zz_fuzz(fd, b, numbytes);
    360         *addr = (vm_offset_t)b;
    361         /* FIXME: the map is never freed; there is no such thing as unmap_fd,
    362          * but I suppose that kind of map should go when the filedescriptor is
    363          * closed (unlike mmap, which returns a persistent buffer). */
    364 
    365         if(numbytes >= 4)
    366            debug("map_fd(%i, %lli, &%p, %i, %lli) = %i \"%c%c%c%c", fd,
    367                  (long long int)offset, (void *)*addr, (int)find_space,
    368                  (long long int)numbytes, ret, b[0], b[1], b[2], b[3]);
    369         else
    370            debug("map_fd(%i, %lli, &%p, %i, %lli) = %i \"%c", fd,
    371                  (long long int)offset, (void *)*addr, (int)find_space,
    372                  (long long int)numbytes, ret, b[0]);
    373     }
    374     else
    375         debug("map_fd(%i, %lli, &%p, %i, %lli) = %i", fd, (long long int)offset,
    376               (void *)*addr, (int)find_space, (long long int)numbytes, ret);
    377 
    378     return ret;
    379 }
    380 #endif
    381 
    382236int close(int fd)
    383237{
  • zzuf/trunk/src/load-mem.c

    r1638 r1639  
    11/*
    22 *  zzuf - general purpose fuzzer
    3  *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2006,2007 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    1414
    1515/*
    16  *  load-fd.c: loaded file descriptor functions
     16 *  load-mem.c: loaded memory handling functions
    1717 */
    1818
    1919#include "config.h"
    2020
    21 /* Can't remember what that's for */
     21/* Need this for RTLD_NEXT */
    2222#define _GNU_SOURCE
    23 /* Use this to get lseek64() on glibc systems */
     23/* Use this to get mmap64() on glibc systems */
    2424#define _LARGEFILE64_SOURCE
    2525
     
    3333#include <dlfcn.h>
    3434
    35 #include <sys/types.h>
    36 #include <sys/socket.h>
     35#include <unistd.h>
    3736#include <sys/mman.h>
    38 #include <unistd.h>
    39 #include <fcntl.h>
    40 #include <stdarg.h>
    4137#if defined HAVE_LIBC_H
    4238#   include <libc.h>
     
    4945#include "fd.h"
    5046
    51 #ifdef HAVE_SOCKLEN_T
    52 #   define SOCKLEN_T socklen_t
    53 #else
    54 #   define SOCKLEN_T int
    55 #endif
    56 
    5747/* Library functions that we divert */
    58 static int     (*open_orig)    (const char *file, int oflag, ...);
    59 #ifdef HAVE_OPEN64
    60 static int     (*open64_orig)  (const char *file, int oflag, ...);
    61 #endif
    62 static int     (*accept_orig)  (int sockfd, struct sockaddr *addr,
    63                                 SOCKLEN_T *addrlen);
    64 static int     (*socket_orig)  (int domain, int type, int protocol);
    65 static ssize_t (*read_orig)    (int fd, void *buf, size_t count);
    66 static off_t   (*lseek_orig)   (int fd, off_t offset, int whence);
    67 #ifdef HAVE_LSEEK64
    68 static off64_t (*lseek64_orig) (int fd, off64_t offset, int whence);
    69 #endif
    7048static void *  (*mmap_orig)    (void *start, size_t length, int prot,
    7149                                int flags, int fd, off_t offset);
    72 #ifdef HAVE_LSEEK64
     50#ifdef HAVE_MMAP64
    7351static void *  (*mmap64_orig)  (void *start, size_t length, int prot,
    7452                                int flags, int fd, off64_t offset);
     
    8058                                     vm_size_t numbytes);
    8159#endif
    82 static int     (*close_orig)   (int fd);
    8360
    84 
    85 void _zz_load_fd(void)
     61void _zz_load_mem(void)
    8662{
    87     LOADSYM(open);
    88 #ifdef HAVE_OPEN64
    89     LOADSYM(open64);
    90 #endif
    91     LOADSYM(accept);
    92     LOADSYM(socket);
    93     LOADSYM(read);
    94     LOADSYM(lseek);
    95 #ifdef HAVE_LSEEK64
    96     LOADSYM(lseek64);
    97 #endif
    9863    LOADSYM(mmap);
    9964#ifdef HAVE_MMAP64
     
    10469    LOADSYM(map_fd);
    10570#endif
    106     LOADSYM(close);
    10771}
    10872
    109 #define OPEN(fn) \
    110     do \
    111     { \
    112         int mode = 0; \
    113         if(!_zz_ready) \
    114             LOADSYM(fn); \
    115         if(oflag & O_CREAT) \
    116         { \
    117             va_list va; \
    118             va_start(va, oflag); \
    119             mode = va_arg(va, int); \
    120             va_end(va); \
    121             ret = ORIG(fn)(file, oflag, mode); \
    122         } \
    123         else \
    124         { \
    125             ret = ORIG(fn)(file, oflag); \
    126         } \
    127         if(!_zz_ready || _zz_disabled) \
    128             return ret; \
    129         if(ret >= 0 \
    130             && ((oflag & (O_RDONLY | O_RDWR | O_WRONLY)) != O_WRONLY) \
    131             && _zz_mustwatch(file)) \
    132         { \
    133             if(oflag & O_CREAT) \
    134                 debug(STR(fn) "(\"%s\", %i, %i) = %i", \
    135                       file, oflag, mode, ret); \
    136             else \
    137                 debug(STR(fn) "(\"%s\", %i) = %i", file, oflag, ret); \
    138             _zz_register(ret); \
    139         } \
    140     } while(0)
    141 
    142 int open(const char *file, int oflag, ...)
    143 {
    144     int ret; OPEN(open); return ret;
    145 }
    146 
    147 #ifdef HAVE_OPEN64
    148 int open64(const char *file, int oflag, ...)
    149 {
    150     int ret; OPEN(open64); return ret;
    151 }
    152 #endif
    153 
    154 int accept(int sockfd, struct sockaddr *addr, SOCKLEN_T *addrlen)
    155 {
    156     int ret;
    157 
    158     if(!_zz_ready)
    159         LOADSYM(accept);
    160     ret = accept_orig(sockfd, addr, addrlen);
    161     if(!_zz_ready || _zz_disabled || !_zz_network)
    162         return ret;
    163 
    164     if(ret >= 0)
    165     {
    166         debug("accept(%i, %p, %p) = %i", sockfd, addr, addrlen, ret);
    167         _zz_register(ret);
    168     }
    169 
    170     return ret;
    171 }
    172 
    173 int socket(int domain, int type, int protocol)
    174 {
    175     int ret;
    176 
    177     if(!_zz_ready)
    178         LOADSYM(socket);
    179     ret = socket_orig(domain, type, protocol);
    180     if(!_zz_ready || _zz_disabled || !_zz_network)
    181         return ret;
    182 
    183     if(ret >= 0)
    184     {
    185         debug("socket(%i, %i, %i) = %i", domain, type, protocol, ret);
    186         _zz_register(ret);
    187     }
    188 
    189     return ret;
    190 }
    191 
    192 ssize_t read(int fd, void *buf, size_t count)
    193 {
    194     int ret;
    195 
    196     if(!_zz_ready)
    197         LOADSYM(read);
    198     ret = read_orig(fd, buf, count);
    199     if(!_zz_ready || !_zz_iswatched(fd) || _zz_disabled)
    200         return ret;
    201 
    202     if(ret > 0)
    203     {
    204         char *b = buf;
    205 
    206         _zz_fuzz(fd, buf, ret);
    207         _zz_addpos(fd, ret);
    208 
    209         if(ret >= 4)
    210             debug("read(%i, %p, %li) = %i \"%c%c%c%c...", fd, buf,
    211                   (long int)count, ret, b[0], b[1], b[2], b[3]);
    212         else
    213             debug("read(%i, %p, %li) = %i \"%c...", fd, buf,
    214                   (long int)count, ret, b[0]);
    215     }
    216     else
    217         debug("read(%i, %p, %li) = %i", fd, buf, (long int)count, ret);
    218 
    219     /* Sanity check, can be OK though (for instance with a character device) */
    220 #ifdef HAVE_LSEEK64
    221     if(lseek64_orig(fd, 0, SEEK_CUR) != _zz_getpos(fd))
    222 #else
    223     if(lseek_orig(fd, 0, SEEK_CUR) != _zz_getpos(fd))
    224 #endif
    225         debug("warning: offset inconsistency");
    226 
    227     return ret;
    228 }
    229 
    230 #define LSEEK(fn, off_t) \
    231     do \
    232     { \
    233         if(!_zz_ready) \
    234             LOADSYM(fn); \
    235         ret = ORIG(fn)(fd, offset, whence); \
    236         if(!_zz_ready || !_zz_iswatched(fd) || _zz_disabled) \
    237             return ret; \
    238         debug(STR(fn)"(%i, %lli, %i) = %lli", \
    239               fd, (long long int)offset, whence, (long long int)ret); \
    240         if(ret != (off_t)-1) \
    241             _zz_setpos(fd, ret); \
    242     } while(0)
    243 
    244 off_t lseek(int fd, off_t offset, int whence)
    245 {
    246     off_t ret;
    247     LSEEK(lseek, off_t);
    248     return ret;
    249 }
    250 
    251 #ifdef HAVE_LSEEK64
    252 off64_t lseek64(int fd, off64_t offset, int whence)
    253 {
    254     off64_t ret;
    255     LSEEK(lseek64, off64_t);
    256     return ret;
    257 }
    258 #endif
    259 
    260 /* Used for mmap() and munmap() */
     73/* Table used for mmap() and munmap() */
    26174void **maps = NULL;
    26275int nbmaps = 0;
     
    380193#endif
    381194
    382 int close(int fd)
    383 {
    384     int ret;
    385 
    386     if(!_zz_ready)
    387         LOADSYM(close);
    388 
    389     /* Hey, it’s our debug channel! Silently pretend we closed it. */
    390     if(fd == DEBUG_FILENO)
    391         return 0;
    392 
    393     ret = close_orig(fd);
    394     if(!_zz_ready || !_zz_iswatched(fd) || _zz_disabled)
    395         return ret;
    396 
    397     debug("close(%i) = %i", fd, ret);
    398     _zz_unregister(fd);
    399 
    400     return ret;
    401 }
    402 
  • zzuf/trunk/src/load.h

    r1532 r1639  
    2828
    2929extern void _zz_load_fd(void);
     30extern void _zz_load_mem(void);
    3031extern void _zz_load_signal(void);
    3132extern void _zz_load_stream(void);
Note: See TracChangeset for help on using the changeset viewer.