Changeset 1699 for zzuf


Ignore:
Timestamp:
Jan 23, 2007, 9:45:47 AM (14 years ago)
Author:
Sam Hocevar
Message:
  • Put either ORIG() or NEW(() around functions, because the naming scheme is likely to change for the Win32 port.
Location:
zzuf/trunk/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • zzuf/trunk/src/lib-fd.c

    r1696 r1699  
    3636#include <stdio.h>
    3737
     38#if defined HAVE_WINSOCK2_H
     39#   include <winsock2.h>
     40#endif
    3841#include <sys/types.h>
    3942#if defined HAVE_SYS_SOCKET_H
     
    6972
    7073/* Library functions that we divert */
    71 static int     (*open_orig)    (const char *file, int oflag, ...);
     74static int     (*ORIG(open))    (const char *file, int oflag, ...);
    7275#if defined HAVE_OPEN64
    73 static int     (*open64_orig)  (const char *file, int oflag, ...);
     76static int     (*ORIG(open64))  (const char *file, int oflag, ...);
    7477#endif
    7578#if defined HAVE_ACCEPT
    76 static int     (*accept_orig)  (int sockfd, struct sockaddr *addr,
    77                                 SOCKLEN_T *addrlen);
     79static int     (*ORIG(accept))  (int sockfd, struct sockaddr *addr,
     80                                 SOCKLEN_T *addrlen);
    7881#endif
    7982#if defined HAVE_SOCKET
    80 static int     (*socket_orig)  (int domain, int type, int protocol);
     83static int     (*ORIG(socket))  (int domain, int type, int protocol);
    8184#endif
    8285#if defined HAVE_RECV
    83 static RECV_T  (*recv_orig)    (int s, void *buf, size_t len, int flags);
     86static RECV_T  (*ORIG(recv))    (int s, void *buf, size_t len, int flags);
    8487#endif
    8588#if defined HAVE_RECVFROM
    86 static RECV_T  (*recvfrom_orig)(int s, void *buf, size_t len, int flags,
    87                                 struct sockaddr *from, SOCKLEN_T *fromlen);
     89static RECV_T  (*ORIG(recvfrom))(int s, void *buf, size_t len, int flags,
     90                                 struct sockaddr *from, SOCKLEN_T *fromlen);
    8891#endif
    8992#if defined HAVE_RECVMSG
    90 static RECV_T  (*recvmsg_orig) (int s,  struct msghdr *hdr, int flags);
     93static RECV_T  (*ORIG(recvmsg)) (int s,  struct msghdr *hdr, int flags);
    9194#endif
    9295#if defined READ_USES_SSIZE_T
    93 static ssize_t (*read_orig)    (int fd, void *buf, size_t count);
     96static ssize_t (*ORIG(read))    (int fd, void *buf, size_t count);
    9497#else
    95 static int     (*read_orig)    (int fd, void *buf, unsigned int count);
     98static int     (*ORIG(read))    (int fd, void *buf, unsigned int count);
    9699#endif
    97100#if defined HAVE_READV
    98 static ssize_t (*readv_orig)   (int fd, const struct iovec *iov, int count);
     101static ssize_t (*ORIG(readv))   (int fd, const struct iovec *iov, int count);
    99102#endif
    100103#if defined HAVE_PREAD
    101 static ssize_t (*pread_orig)   (int fd, void *buf, size_t count, off_t offset);
     104static ssize_t (*ORIG(pread))   (int fd, void *buf, size_t count, off_t offset);
    102105#endif
    103106#if defined HAVE_AIO_READ
    104 static int     (*aio_read_orig)   (struct aiocb *aiocbp);
    105 static ssize_t (*aio_return_orig) (struct aiocb *aiocbp);
    106 #endif
    107 static off_t   (*lseek_orig)   (int fd, off_t offset, int whence);
     107static int     (*ORIG(aio_read))   (struct aiocb *aiocbp);
     108static ssize_t (*ORIG(aio_return)) (struct aiocb *aiocbp);
     109#endif
     110static off_t   (*ORIG(lseek))   (int fd, off_t offset, int whence);
    108111#if defined HAVE_LSEEK64
    109 static off64_t (*lseek64_orig) (int fd, off64_t offset, int whence);
    110 #endif
    111 static int     (*close_orig)   (int fd);
     112static off64_t (*ORIG(lseek64)) (int fd, off64_t offset, int whence);
     113#endif
     114static int     (*ORIG(close))   (int fd);
    112115
    113116#define OPEN(fn) \
     
    143146    } while(0)
    144147
    145 int open(const char *file, int oflag, ...)
     148int NEW(open)(const char *file, int oflag, ...)
    146149{
    147150    int ret; OPEN(open); return ret;
     
    149152
    150153#if defined HAVE_OPEN64
    151 int open64(const char *file, int oflag, ...)
     154int NEW(open64)(const char *file, int oflag, ...)
    152155{
    153156    int ret; OPEN(open64); return ret;
     
    156159
    157160#if defined HAVE_ACCEPT
    158 int accept(int sockfd, struct sockaddr *addr, SOCKLEN_T *addrlen)
     161int NEW(accept)(int sockfd, struct sockaddr *addr, SOCKLEN_T *addrlen)
    159162{
    160163    int ret;
    161164
    162165    LOADSYM(accept);
    163     ret = accept_orig(sockfd, addr, addrlen);
     166    ret = ORIG(accept)(sockfd, addr, addrlen);
    164167    if(!_zz_ready || _zz_islocked(-1) || !_zz_network)
    165168        return ret;
     
    176179
    177180#if defined HAVE_SOCKET
    178 int socket(int domain, int type, int protocol)
     181int NEW(socket)(int domain, int type, int protocol)
    179182{
    180183    int ret;
    181184
    182185    LOADSYM(socket);
    183     ret = socket_orig(domain, type, protocol);
     186    ret = ORIG(socket)(domain, type, protocol);
    184187    if(!_zz_ready || _zz_islocked(-1) || !_zz_network)
    185188        return ret;
     
    196199
    197200#if defined HAVE_RECV
    198 RECV_T recv(int s, void *buf, size_t len, int flags)
     201RECV_T NEW(recv)(int s, void *buf, size_t len, int flags)
    199202{
    200203    int ret;
    201204
    202205    LOADSYM(recv);
    203     ret = recv_orig(s, buf, len, flags);
     206    ret = ORIG(recv)(s, buf, len, flags);
    204207    if(!_zz_ready || !_zz_iswatched(s) || _zz_islocked(s))
    205208        return ret;
     
    228231
    229232#if defined HAVE_RECVFROM
    230 RECV_T recvfrom(int s, void *buf, size_t len, int flags,
    231              struct sockaddr *from, SOCKLEN_T *fromlen)
     233RECV_T NEW(recvfrom)(int s, void *buf, size_t len, int flags,
     234                     struct sockaddr *from, SOCKLEN_T *fromlen)
    232235{
    233236    int ret;
    234237
    235238    LOADSYM(recvfrom);
    236     ret = recvfrom_orig(s, buf, len, flags, from, fromlen);
     239    ret = ORIG(recvfrom)(s, buf, len, flags, from, fromlen);
    237240    if(!_zz_ready || !_zz_iswatched(s) || _zz_islocked(s))
    238241        return ret;
     
    262265
    263266#if defined HAVE_RECVMSG
    264 RECV_T recvmsg(int s, struct msghdr *hdr, int flags)
     267RECV_T NEW(recvmsg)(int s, struct msghdr *hdr, int flags)
    265268{
    266269    ssize_t ret;
    267270
    268271    LOADSYM(recvmsg);
    269     ret = recvmsg_orig(s, hdr, flags);
     272    ret = ORIG(recvmsg)(s, hdr, flags);
    270273    if(!_zz_ready || !_zz_iswatched(s) || _zz_islocked(s))
    271274        return ret;
     
    279282
    280283#if defined READ_USES_SSIZE_T
    281 ssize_t read(int fd, void *buf, size_t count)
     284ssize_t NEW(read)(int fd, void *buf, size_t count)
    282285#else
    283 int read(int fd, void *buf, unsigned int count)
     286int NEW(read)(int fd, void *buf, unsigned int count)
    284287#endif
    285288{
     
    287290
    288291    LOADSYM(read);
    289     ret = read_orig(fd, buf, count);
     292    ret = ORIG(read)(fd, buf, count);
    290293    if(!_zz_ready || !_zz_iswatched(fd) || _zz_islocked(fd))
    291294        return ret;
     
    313316
    314317#if defined HAVE_READV
    315 ssize_t readv(int fd, const struct iovec *iov, int count)
     318ssize_t NEW(readv)(int fd, const struct iovec *iov, int count)
    316319{
    317320    ssize_t ret;
    318321
    319322    LOADSYM(readv);
    320     ret = readv_orig(fd, iov, count);
     323    ret = ORIG(readv)(fd, iov, count);
    321324    if(!_zz_ready || !_zz_iswatched(fd) || _zz_islocked(fd))
    322325        return ret;
     
    331334
    332335#if defined HAVE_PREAD
    333 ssize_t pread(int fd, void *buf, size_t count, off_t offset)
     336ssize_t NEW(pread)(int fd, void *buf, size_t count, off_t offset)
    334337{
    335338    int ret;
    336339
    337340    LOADSYM(pread);
    338     ret = pread_orig(fd, buf, count, offset);
     341    ret = ORIG(pread)(fd, buf, count, offset);
    339342    if(!_zz_ready || !_zz_iswatched(fd) || _zz_islocked(fd))
    340343        return ret;
     
    378381    } while(0)
    379382
    380 off_t lseek(int fd, off_t offset, int whence)
     383off_t NEW(lseek)(int fd, off_t offset, int whence)
    381384{
    382385    off_t ret;
     
    386389
    387390#if defined HAVE_LSEEK64
    388 off64_t lseek64(int fd, off64_t offset, int whence)
     391off64_t NEW(lseek64)(int fd, off64_t offset, int whence)
    389392{
    390393    off64_t ret;
     
    395398
    396399#if defined HAVE_AIO_READ
    397 int aio_read(struct aiocb *aiocbp)
     400int NEW(aio_read)(struct aiocb *aiocbp)
    398401{
    399402    int ret;
     
    402405    LOADSYM(aio_read);
    403406    if(!_zz_ready || !_zz_iswatched(fd))
    404         return aio_read_orig(aiocbp);
     407        return ORIG(aio_read)(aiocbp);
    405408
    406409    _zz_lock(fd);
    407     ret = aio_read_orig(aiocbp);
     410    ret = ORIG(aio_read)(aiocbp);
    408411
    409412    debug("%s({%i, %i, %i, %p, %li, ..., %li}) = %i", __func__,
     
    414417}
    415418
    416 ssize_t aio_return(struct aiocb *aiocbp)
     419ssize_t NEW(aio_return)(struct aiocb *aiocbp)
    417420{
    418421    ssize_t ret;
     
    421424    LOADSYM(aio_return);
    422425    if(!_zz_ready || !_zz_iswatched(fd))
    423         return aio_return_orig(aiocbp);
    424 
    425     ret = aio_return_orig(aiocbp);
     426        return ORIG(aio_return)(aiocbp);
     427
     428    ret = ORIG(aio_return)(aiocbp);
    426429    _zz_unlock(fd);
    427430
     
    443446#endif
    444447
    445 int close(int fd)
     448int NEW(close)(int fd)
    446449{
    447450    int ret;
     
    452455
    453456    LOADSYM(close);
    454     ret = close_orig(fd);
     457    ret = ORIG(close)(fd);
    455458    if(!_zz_ready || !_zz_iswatched(fd) || _zz_islocked(fd))
    456459        return ret;
     
    491494    off64_t ret;
    492495    LOADSYM(lseek64);
    493     ret = lseek64_orig(fd, 0, SEEK_CUR);
     496    ret = ORIG(lseek64)(fd, 0, SEEK_CUR);
    494497#else
    495498    off_t ret;
    496499    LOADSYM(lseek);
    497     ret = lseek_orig(fd, 0, SEEK_CUR);
     500    ret = ORIG(lseek)(fd, 0, SEEK_CUR);
    498501#endif
    499502    if(ret != -1 && ret != _zz_getpos(fd))
  • zzuf/trunk/src/lib-load.h

    r1695 r1699  
    2929#define STR(x) #x
    3030#define ORIG(x) x##_orig
     31#ifdef HAVE_DLFCN_H
     32#   define NEW(x) x
     33#else
     34#   define NEW(x) x##_new
     35#endif
    3136
    3237/* TODO: do the Win32 part */
  • zzuf/trunk/src/lib-mem.c

    r1695 r1699  
    6262
    6363/* Library functions that we divert */
    64 static void *  (*calloc_orig)   (size_t nmemb, size_t size);
    65 static void *  (*malloc_orig)   (size_t size);
    66 static void    (*free_orig)     (void *ptr);
     64static void *  (*ORIG(calloc))   (size_t nmemb, size_t size);
     65static void *  (*ORIG(malloc))   (size_t size);
     66static void    (*ORIG(free))     (void *ptr);
    6767#if defined HAVE_VALLOC
    68 static void *  (*valloc_orig)   (size_t size);
     68static void *  (*ORIG(valloc))   (size_t size);
    6969#endif
    7070#if defined HAVE_MEMALIGN
    71 static void *  (*memalign_orig) (size_t boundary, size_t size);
     71static void *  (*ORIG(memalign)) (size_t boundary, size_t size);
    7272#endif
    7373#if defined HAVE_POSIX_MEMALIGN
    74 static int     (*posix_memalign_orig) (void **memptr, size_t alignment,
    75                                        size_t size);
    76 #endif
    77 static void *  (*realloc_orig)  (void *ptr, size_t size);
     74static int     (*ORIG(posix_memalign)) (void **memptr, size_t alignment,
     75                                        size_t size);
     76#endif
     77static void *  (*ORIG(realloc))  (void *ptr, size_t size);
    7878
    7979#if defined HAVE_MMAP
    80 static void *  (*mmap_orig)     (void *start, size_t length, int prot,
    81                                  int flags, int fd, off_t offset);
     80static void *  (*ORIG(mmap))     (void *start, size_t length, int prot,
     81                                  int flags, int fd, off_t offset);
    8282#endif
    8383#if defined HAVE_MMAP64
    84 static void *  (*mmap64_orig)   (void *start, size_t length, int prot,
    85                                  int flags, int fd, off64_t offset);
     84static void *  (*ORIG(mmap64))   (void *start, size_t length, int prot,
     85                                  int flags, int fd, off64_t offset);
    8686#endif
    8787#if defined HAVE_MUNMAP
    88 static int     (*munmap_orig)   (void *start, size_t length);
     88static int     (*ORIG(munmap))   (void *start, size_t length);
    8989#endif
    9090#if defined HAVE_MAP_FD
    91 static kern_return_t (*map_fd_orig) (int fd, vm_offset_t offset,
    92                                      vm_offset_t *addr, boolean_t find_space,
    93                                      vm_size_t numbytes);
     91static kern_return_t (*ORIG(map_fd)) (int fd, vm_offset_t offset,
     92                                      vm_offset_t *addr, boolean_t find_space,
     93                                      vm_size_t numbytes);
    9494#endif
    9595
     
    103103#define DUMMY_STOP ((uintptr_t)dummy_buffer + DUMMY_BYTES)
    104104
    105 void *calloc(size_t nmemb, size_t size)
    106 {
    107     void *ret;
    108     if(!calloc_orig)
     105void *NEW(calloc)(size_t nmemb, size_t size)
     106{
     107    void *ret;
     108    if(!ORIG(calloc))
    109109    {
    110110        ret = dummy_buffer + dummy_offset;
     
    113113        return ret;
    114114    }
    115     ret = calloc_orig(nmemb, size);
    116     if(ret == NULL && _zz_memory && errno == ENOMEM)
    117         raise(SIGKILL);
    118     return ret;
    119 }
    120 
    121 void *malloc(size_t size)
    122 {
    123     void *ret;
    124     if(!malloc_orig)
     115    ret = ORIG(calloc)(nmemb, size);
     116    if(ret == NULL && _zz_memory && errno == ENOMEM)
     117        raise(SIGKILL);
     118    return ret;
     119}
     120
     121void *NEW(malloc)(size_t size)
     122{
     123    void *ret;
     124    if(!ORIG(malloc))
    125125    {
    126126        ret = dummy_buffer + dummy_offset;
     
    128128        return ret;
    129129    }
    130     ret = malloc_orig(size);
    131     if(ret == NULL && _zz_memory && errno == ENOMEM)
    132         raise(SIGKILL);
    133     return ret;
    134 }
    135 
    136 void free(void *ptr)
     130    ret = ORIG(malloc)(size);
     131    if(ret == NULL && _zz_memory && errno == ENOMEM)
     132        raise(SIGKILL);
     133    return ret;
     134}
     135
     136void NEW(free)(void *ptr)
    137137{
    138138    if((uintptr_t)ptr >= DUMMY_START && (uintptr_t)ptr < DUMMY_STOP)
    139139        return;
    140140    LOADSYM(free);
    141     free_orig(ptr);
    142 }
    143 
    144 void *realloc(void *ptr, size_t size)
     141    ORIG(free)(ptr);
     142}
     143
     144void *NEW(realloc)(void *ptr, size_t size)
    145145{
    146146    void *ret;
     
    153153    }
    154154    LOADSYM(realloc);
    155     ret = realloc_orig(ptr, size);
     155    ret = ORIG(realloc)(ptr, size);
    156156    if(ret == NULL && _zz_memory && errno == ENOMEM)
    157157        raise(SIGKILL);
     
    160160
    161161#if defined HAVE_VALLOC
    162 void *valloc(size_t size)
     162void *NEW(valloc)(size_t size)
    163163{
    164164    void *ret;
    165165    LOADSYM(valloc);
    166     ret = valloc_orig(size);
     166    ret = ORIG(valloc)(size);
    167167    if(ret == NULL && _zz_memory && errno == ENOMEM)
    168168        raise(SIGKILL);
     
    172172
    173173#if defined HAVE_MEMALIGN
    174 void *memalign(size_t boundary, size_t size)
     174void *NEW(memalign)(size_t boundary, size_t size)
    175175{
    176176    void *ret;
    177177    LOADSYM(memalign);
    178     ret = memalign_orig(boundary, size);
     178    ret = ORIG(memalign)(boundary, size);
    179179    if(ret == NULL && _zz_memory && errno == ENOMEM)
    180180        raise(SIGKILL);
     
    184184
    185185#if defined HAVE_POSIX_MEMALIGN
    186 int posix_memalign(void **memptr, size_t alignment, size_t size)
     186int NEW(posix_memalign)(void **memptr, size_t alignment, size_t size)
    187187{
    188188    int ret;
    189189    LOADSYM(posix_memalign);
    190     ret = posix_memalign_orig(memptr, alignment, size);
     190    ret = ORIG(posix_memalign)(memptr, alignment, size);
    191191    if(ret == ENOMEM && _zz_memory)
    192192        raise(SIGKILL);
     
    241241
    242242#if defined HAVE_MMAP
    243 void *mmap(void *start, size_t length, int prot, int flags,
    244            int fd, off_t offset)
     243void *NEW(mmap)(void *start, size_t length, int prot, int flags,
     244                int fd, off_t offset)
    245245{
    246246    void *ret; MMAP(mmap, off_t); return ret;
     
    249249
    250250#if defined HAVE_MMAP64
    251 void *mmap64(void *start, size_t length, int prot, int flags,
    252              int fd, off64_t offset)
     251void *NEW(mmap64)(void *start, size_t length, int prot, int flags,
     252                  int fd, off64_t offset)
    253253{
    254254    void *ret; MMAP(mmap64, off64_t); return ret;
     
    257257
    258258#if defined HAVE_MUNMAP
    259 int munmap(void *start, size_t length)
     259int NEW(munmap)(void *start, size_t length)
    260260{
    261261    int ret, i;
     
    268268
    269269        free(start);
    270         ret = munmap_orig(maps[i + 1], length);
     270        ret = ORIG(munmap)(maps[i + 1], length);
    271271        maps[i] = NULL;
    272272        maps[i + 1] = NULL;
     
    275275    }
    276276
    277     return munmap_orig(start, length);
     277    return ORIG(munmap)(start, length);
    278278}
    279279#endif
    280280
    281281#if defined HAVE_MAP_FD
    282 kern_return_t map_fd(int fd, vm_offset_t offset, vm_offset_t *addr,
    283                      boolean_t find_space, vm_size_t numbytes)
     282kern_return_t NEW(map_fd)(int fd, vm_offset_t offset, vm_offset_t *addr,
     283                          boolean_t find_space, vm_size_t numbytes)
    284284{
    285285    kern_return_t ret;
    286286
    287287    LOADSYM(map_fd);
    288     ret = map_fd_orig(fd, offset, addr, find_space, numbytes);
     288    ret = ORIG(map_fd)(fd, offset, addr, find_space, numbytes);
    289289    if(!_zz_ready || !_zz_iswatched(fd) || _zz_islocked(fd))
    290290        return ret;
  • zzuf/trunk/src/lib-signal.c

    r1695 r1699  
    4646
    4747/* Library functions that we divert */
    48 static SIG_T (*signal_orig)    (int signum, SIG_T handler);
     48static SIG_T (*ORIG(signal))    (int signum, SIG_T handler);
    4949#if defined HAVE_SIGACTION
    50 static int   (*sigaction_orig) (int signum, const struct sigaction *act,
    51                                 struct sigaction *oldact);
     50static int   (*ORIG(sigaction)) (int signum, const struct sigaction *act,
     51                                 struct sigaction *oldact);
    5252#endif
    5353/* Local functions */
     
    8989}
    9090
    91 SIG_T signal(int signum, SIG_T handler)
     91SIG_T NEW(signal)(int signum, SIG_T handler)
    9292{
    9393    SIG_T ret;
     
    9696
    9797    if(!_zz_signal)
    98         return signal_orig(signum, handler);
     98        return ORIG(signal)(signum, handler);
    9999
    100     ret = signal_orig(signum, isfatal(signum) ? SIG_DFL : handler);
     100    ret = ORIG(signal)(signum, isfatal(signum) ? SIG_DFL : handler);
    101101
    102102    debug("%s(%i, %p) = %p", __func__, signum, handler, ret);
     
    106106
    107107#if defined HAVE_SIGACTION
    108 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
     108int NEW(sigaction)(int signum, const struct sigaction *act,
     109                   struct sigaction *oldact)
    109110{
    110111    int ret;
     
    113114
    114115    if(!_zz_signal)
    115         return sigaction_orig(signum, act, oldact);
     116        return ORIG(sigaction)(signum, act, oldact);
    116117
    117118    if(act && isfatal(signum))
     
    120121        memcpy(&newact, act, sizeof(struct sigaction));
    121122        newact.sa_handler = SIG_DFL;
    122         ret = sigaction_orig(signum, &newact, oldact);
     123        ret = ORIG(sigaction)(signum, &newact, oldact);
    123124    }
    124125    else
    125         ret = sigaction_orig(signum, act, oldact);
     126        ret = ORIG(sigaction)(signum, act, oldact);
    126127
    127128    debug("%s(%i, %p, %p) = %i", __func__, signum, act, oldact, ret);
  • zzuf/trunk/src/lib-stream.c

    r1697 r1699  
    4141
    4242#if defined HAVE___SREFILL
    43 int __srefill(FILE *fp);
     43int NEW(__srefill)(FILE *fp);
    4444#endif
    4545
    4646/* Library functions that we divert */
    47 static FILE *  (*fopen_orig)    (const char *path, const char *mode);
     47static FILE *  (*ORIG(fopen))    (const char *path, const char *mode);
    4848#if defined HAVE_FOPEN64
    49 static FILE *  (*fopen64_orig)  (const char *path, const char *mode);
    50 #endif
    51 static FILE *  (*freopen_orig)  (const char *path, const char *mode,
    52                                  FILE *stream);
    53 static int     (*fseek_orig)    (FILE *stream, long offset, int whence);
     49static FILE *  (*ORIG(fopen64))  (const char *path, const char *mode);
     50#endif
     51static FILE *  (*ORIG(freopen))  (const char *path, const char *mode,
     52                                  FILE *stream);
     53static int     (*ORIG(fseek))    (FILE *stream, long offset, int whence);
    5454#if defined HAVE_FSEEKO
    55 static int     (*fseeko_orig)   (FILE *stream, off_t offset, int whence);
    56 #endif
    57 static void    (*rewind_orig)   (FILE *stream);
    58 static size_t  (*fread_orig)    (void *ptr, size_t size, size_t nmemb,
    59                                  FILE *stream);
    60 static int     (*getc_orig)     (FILE *stream);
    61 static int     (*fgetc_orig)    (FILE *stream);
     55static int     (*ORIG(fseeko))   (FILE *stream, off_t offset, int whence);
     56#endif
     57static void    (*ORIG(rewind))   (FILE *stream);
     58static size_t  (*ORIG(fread))    (void *ptr, size_t size, size_t nmemb,
     59                                  FILE *stream);
     60static int     (*ORIG(getc))     (FILE *stream);
     61static int     (*ORIG(fgetc))    (FILE *stream);
    6262#if defined HAVE__IO_GETC
    63 static int     (*_IO_getc_orig) (FILE *stream);
    64 #endif
    65 static char *  (*fgets_orig)    (char *s, int size, FILE *stream);
    66 static int     (*ungetc_orig)   (int c, FILE *stream);
    67 static int     (*fclose_orig)   (FILE *fp);
     63static int     (*ORIG(_IO_getc)) (FILE *stream);
     64#endif
     65static char *  (*ORIG(fgets))    (char *s, int size, FILE *stream);
     66static int     (*ORIG(ungetc))   (int c, FILE *stream);
     67static int     (*ORIG(fclose))   (FILE *fp);
    6868
    6969/* Additional GNUisms */
    7070#if defined HAVE_GETLINE
    71 static ssize_t (*getline_orig)    (char **lineptr, size_t *n, FILE *stream);
     71static ssize_t (*ORIG(getline))    (char **lineptr, size_t *n, FILE *stream);
    7272#endif
    7373#if defined HAVE_GETDELIM
    74 static ssize_t (*getdelim_orig)   (char **lineptr, size_t *n, int delim,
    75                                    FILE *stream);
     74static ssize_t (*ORIG(getdelim))   (char **lineptr, size_t *n, int delim,
     75                                    FILE *stream);
    7676#endif
    7777#if defined HAVE___GETDELIM
    78 static ssize_t (*__getdelim_orig) (char **lineptr, size_t *n, int delim,
    79                                    FILE *stream);
     78static ssize_t (*ORIG(__getdelim)) (char **lineptr, size_t *n, int delim,
     79                                    FILE *stream);
    8080#endif
    8181
    8282/* Additional BSDisms */
    8383#if defined HAVE_FGETLN
    84 static char *  (*fgetln_orig)    (FILE *stream, size_t *len);
     84static char *  (*ORIG(fgetln))    (FILE *stream, size_t *len);
    8585#endif
    8686#if defined HAVE___SREFILL
    87 int            (*__srefill_orig) (FILE *fp);
     87int            (*ORIG(__srefill)) (FILE *fp);
    8888#endif
    8989
     
    106106    } while(0)
    107107
    108 FILE *fopen(const char *path, const char *mode)
     108FILE *NEW(fopen)(const char *path, const char *mode)
    109109{
    110110    FILE *ret; FOPEN(fopen); return ret;
     
    112112
    113113#if defined HAVE_FOPEN64
    114 FILE *fopen64(const char *path, const char *mode)
     114FILE *NEW(fopen64)(const char *path, const char *mode)
    115115{
    116116    FILE *ret; FOPEN(fopen64); return ret;
     
    118118#endif
    119119
    120 FILE *freopen(const char *path, const char *mode, FILE *stream)
     120FILE *NEW(freopen)(const char *path, const char *mode, FILE *stream)
    121121{
    122122    FILE *ret;
     
    131131
    132132    _zz_lock(-1);
    133     ret = freopen_orig(path, mode, stream);
     133    ret = ORIG(freopen)(path, mode, stream);
    134134    _zz_unlock(-1);
    135135
     
    186186    } while(0)
    187187
    188 int fseek(FILE *stream, long offset, int whence)
     188int NEW(fseek)(FILE *stream, long offset, int whence)
    189189{
    190190    int ret; FSEEK(fseek, ftell); return ret;
     
    192192
    193193#if defined HAVE_FSEEKO
    194 int fseeko(FILE *stream, off_t offset, int whence)
     194int NEW(fseeko)(FILE *stream, off_t offset, int whence)
    195195{
    196196    int ret; FSEEK(fseeko, ftello); return ret;
     
    198198#endif
    199199
    200 void rewind(FILE *stream)
     200void NEW(rewind)(FILE *stream)
    201201{
    202202    int fd;
     
    206206    if(!_zz_ready || !_zz_iswatched(fd))
    207207    {
    208         rewind_orig(stream);
     208        ORIG(rewind)(stream);
    209209        return;
    210210    }
    211211
    212212    _zz_lock(fd);
    213     rewind_orig(stream);
     213    ORIG(rewind)(stream);
    214214    _zz_unlock(fd);
    215215    debug("%s([%i])", __func__, fd);
     
    222222}
    223223
    224 size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
     224size_t NEW(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
    225225{
    226226    long int pos;
     
    235235    fd = fileno(stream);
    236236    if(!_zz_ready || !_zz_iswatched(fd))
    237         return fread_orig(ptr, size, nmemb, stream);
     237        return ORIG(fread)(ptr, size, nmemb, stream);
    238238
    239239    pos = ftell(stream);
    240240    _zz_lock(fd);
    241     ret = fread_orig(ptr, size, nmemb, stream);
     241    ret = ORIG(fread)(ptr, size, nmemb, stream);
    242242    _zz_unlock(fd);
    243243    debug("%s(%p, %li, %li, [%i]) = %li", __func__, ptr,
     
    291291
    292292#undef getc /* can be a macro; we don’t want that */
    293 int getc(FILE *stream)
     293int NEW(getc)(FILE *stream)
    294294{
    295295    int ret; FGETC(getc); return ret;
    296296}
    297297
    298 int fgetc(FILE *stream)
     298int NEW(fgetc)(FILE *stream)
    299299{
    300300    int ret; FGETC(fgetc); return ret;
     
    302302
    303303#if defined HAVE__IO_GETC
    304 int _IO_getc(FILE *stream)
     304int NEW(_IO_getc)(FILE *stream)
    305305{
    306306    int ret; FGETC(_IO_getc); return ret;
     
    308308#endif
    309309
    310 char *fgets(char *s, int size, FILE *stream)
     310char *NEW(fgets)(char *s, int size, FILE *stream)
    311311{
    312312    char *ret = s;
     
    317317    fd = fileno(stream);
    318318    if(!_zz_ready || !_zz_iswatched(fd))
    319         return fgets_orig(s, size, stream);
    320 
    321 #if defined HAVE___SREFILL /* Don't fuzz or seek if we have __srefill() */
    322     _zz_lock(fd);
    323     ret = fgets_orig(s, size, stream);
     319        return ORIG(fgets)(s, size, stream);
     320
     321#if defined HAVE___SREFILL /* Don't fuzz or seek if we have __srefill() */
     322    _zz_lock(fd);
     323    ret = ORIG(fgets)(s, size, stream);
    324324    _zz_unlock(fd);
    325325#else
     
    337337
    338338            _zz_lock(fd);
    339             ch = fgetc_orig(stream);
     339            ch = ORIG(fgetc)(stream);
    340340            _zz_unlock(fd);
    341341
     
    363363}
    364364
    365 int ungetc(int c, FILE *stream)
     365int NEW(ungetc)(int c, FILE *stream)
    366366{
    367367    unsigned char ch = c;
     
    371371    fd = fileno(stream);
    372372    if(!_zz_ready || !_zz_iswatched(fd))
    373         return ungetc_orig(c, stream);
     373        return ORIG(ungetc)(c, stream);
    374374
    375375#if defined HAVE___SREFILL /* Don't fuzz or seek if we have __srefill() */
     
    379379#endif
    380380    _zz_lock(fd);
    381     ret = ungetc_orig((int)ch, stream);
     381    ret = ORIG(ungetc)((int)ch, stream);
    382382    _zz_unlock(fd);
    383383
     
    394394}
    395395
    396 int fclose(FILE *fp)
     396int NEW(fclose)(FILE *fp)
    397397{
    398398    int ret, fd;
     
    401401    fd = fileno(fp);
    402402    if(!_zz_ready || !_zz_iswatched(fd))
    403         return fclose_orig(fp);
    404 
    405     _zz_lock(fd);
    406     ret = fclose_orig(fp);
     403        return ORIG(fclose)(fp);
     404
     405    _zz_lock(fd);
     406    ret = ORIG(fclose)(fp);
    407407    _zz_unlock(fd);
    408408    debug("%s([%i]) = %i", __func__, fd, ret);
     
    422422        fd = fileno(stream); \
    423423        if(!_zz_ready || !_zz_iswatched(fd)) \
    424             return getdelim_orig(lineptr, n, delim, stream); \
     424            return ORIG(getdelim)(lineptr, n, delim, stream); \
    425425        line = *lineptr; \
    426426        size = line ? *n : 0; \
     
    439439            } \
    440440            _zz_lock(fd); \
    441             ch = fgetc_orig(stream); \
     441            ch = ORIG(fgetc)(stream); \
    442442            _zz_unlock(fd); \
    443443            if(ch == EOF) \
     
    469469
    470470#if defined HAVE_GETLINE
    471 ssize_t getline(char **lineptr, size_t *n, FILE *stream)
     471ssize_t NEW(getline)(char **lineptr, size_t *n, FILE *stream)
    472472{
    473473    ssize_t ret; GETDELIM(getline, '\n', 0); return ret;
     
    476476
    477477#if defined HAVE_GETDELIM
    478 ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream)
     478ssize_t NEW(getdelim)(char **lineptr, size_t *n, int delim, FILE *stream)
    479479{
    480480    ssize_t ret; GETDELIM(getdelim, delim, 1); return ret;
     
    483483
    484484#if defined HAVE___GETDELIM
    485 ssize_t __getdelim(char **lineptr, size_t *n, int delim, FILE *stream)
     485ssize_t NEW(__getdelim)(char **lineptr, size_t *n, int delim, FILE *stream)
    486486{
    487487    ssize_t ret; GETDELIM(__getdelim, delim, 1); return ret;
     
    490490
    491491#if defined HAVE_FGETLN
    492 char *fgetln(FILE *stream, size_t *len)
     492char *NEW(fgetln)(FILE *stream, size_t *len)
    493493{
    494494    char *ret;
     
    504504    fd = fileno(stream);
    505505    if(!_zz_ready || !_zz_iswatched(fd))
    506         return fgetln_orig(stream, len);
    507 
    508 #if defined HAVE___SREFILL /* Don't fuzz or seek if we have __srefill() */
    509     _zz_lock(fd);
    510     ret = fgetln_orig(stream, len);
     506        return ORIG(fgetln)(stream, len);
     507
     508#if defined HAVE___SREFILL /* Don't fuzz or seek if we have __srefill() */
     509    _zz_lock(fd);
     510    ret = ORIG(fgetln)(stream, len);
    511511    _zz_unlock(fd);
    512512#else
     
    518518
    519519        _zz_lock(fd);
    520         ch = fgetc_orig(stream);
     520        ch = ORIG(fgetc)(stream);
    521521        _zz_unlock(fd);
    522522
     
    545545
    546546#if defined HAVE___SREFILL
    547 int __srefill(FILE *fp)
     547int NEW(__srefill)(FILE *fp)
    548548{
    549549    off_t newpos;
     
    553553    fd = fileno(fp);
    554554    if(!_zz_ready || !_zz_iswatched(fd))
    555         return __srefill_orig(fp);
    556 
    557     _zz_lock(fd);
    558     ret = __srefill_orig(fp);
     555        return ORIG(__srefill)(fp);
     556
     557    _zz_lock(fd);
     558    ret = ORIG(__srefill)(fp);
    559559    newpos = lseek(fd, 0, SEEK_CUR);
    560560    _zz_unlock(fd);
  • zzuf/trunk/src/zzuf.c

    r1698 r1699  
    3232#if defined HAVE_REGEX_H
    3333#   include <regex.h>
     34#endif
     35#if defined HAVE_WINSOCK2_H
     36#   include <winsock2.h>
    3437#endif
    3538#include <string.h>
Note: See TracChangeset for help on using the changeset viewer.