Changeset 4375 for zzuf


Ignore:
Timestamp:
Feb 27, 2010, 7:42:01 PM (10 years ago)
Author:
Sam Hocevar
Message:

Fortify functions actually have extra arguments. Fix that.

Location:
zzuf/trunk/src/libzzuf
Files:
2 edited

Legend:

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

    r4373 r4375  
    124124#endif
    125125#if defined HAVE___RECV_CHK
    126 static RECV_T  (*ORIG(__recv_chk)) (int s, void *buf, size_t len, int flags);
     126static RECV_T  (*ORIG(__recv_chk)) (int s, void *buf, size_t len,
     127                                    size_t buflen, int flags);
    127128#endif
    128129#if defined HAVE_RECVFROM
     
    131132#endif
    132133#if defined HAVE___RECVFROM_CHK
    133 static RECV_T  (*ORIG(__recvfrom_chk))(int s, void *buf, size_t len, int flags,
     134static RECV_T  (*ORIG(__recvfrom_chk))(int s, void *buf, size_t len,
     135                                       size_t buflen, int flags,
    134136                                       SOCKADDR_T *from, SOCKLEN_T *fromlen);
    135137#endif
     
    143145#endif
    144146#if defined HAVE___READ_CHK
    145 static ssize_t (*ORIG(__read_chk)) (int fd, void *buf, size_t count);
     147static ssize_t (*ORIG(__read_chk)) (int fd, void *buf, size_t count,
     148                                    size_t buflen);
    146149#endif
    147150#if defined HAVE_READV
     
    372375#endif
    373376
    374 #define ZZ_RECV(myrecv) \
     377#define ZZ_RECV(myrecv, myargs) \
    375378    do \
    376379    { \
    377380        LOADSYM(myrecv); \
    378         ret = ORIG(myrecv)(s, buf, len, flags); \
     381        ret = ORIG(myrecv) myargs; \
    379382        if(!_zz_ready || !_zz_iswatched(s) || !_zz_hostwatched(s) \
    380383             || _zz_islocked(s) || !_zz_isactive(s)) \
     
    402405RECV_T NEW(recv)(int s, void *buf, size_t len, int flags)
    403406{
    404     int ret; ZZ_RECV(recv); return ret;
     407    int ret; ZZ_RECV(recv, (s, buf, len, flags)); return ret;
    405408}
    406409#endif
     
    408411#if defined HAVE___RECV_CHK
    409412#undef __recv_chk
    410 RECV_T NEW(__recv_chk)(int s, void *buf, size_t len, int flags)
    411 {
    412     int ret; ZZ_RECV(__recv_chk); return ret;
    413 }
    414 #endif
    415 
    416 #define ZZ_RECVFROM(myrecvfrom) \
     413RECV_T NEW(__recv_chk)(int s, void *buf, size_t len, size_t buflen, int flags)
     414{
     415    int ret; ZZ_RECV(__recv_chk, (s, buf, len, buflen, flags)); return ret;
     416}
     417#endif
     418
     419#define ZZ_RECVFROM(myrecvfrom, myargs) \
    417420    do \
    418421    { \
    419422        LOADSYM(myrecvfrom); \
    420         ret = ORIG(myrecvfrom)(s, buf, len, flags, from, fromlen); \
     423        ret = ORIG(myrecvfrom) myargs; \
    421424        if(!_zz_ready || !_zz_iswatched(s) || !_zz_hostwatched(s) \
    422425             || _zz_islocked(s) || !_zz_isactive(s)) \
     
    451454                     SOCKADDR_T *from, SOCKLEN_T *fromlen)
    452455{
    453     int ret; ZZ_RECVFROM(recvfrom); return ret;
     456    int ret;
     457    ZZ_RECVFROM(recvfrom, (s, buf, len, flags, from, fromlen));
     458    return ret;
    454459}
    455460#endif
     
    457462#if defined HAVE___RECVFROM_CHK
    458463#undef __recvfrom_chk
    459 RECV_T NEW(__recvfrom_chk)(int s, void *buf, size_t len, int flags,
    460                            SOCKADDR_T *from, SOCKLEN_T *fromlen)
    461 {
    462     int ret; ZZ_RECVFROM(__recvfrom_chk); return ret;
     464RECV_T NEW(__recvfrom_chk)(int s, void *buf, size_t len, size_t buflen,
     465                           int flags, SOCKADDR_T *from, SOCKLEN_T *fromlen)
     466{
     467    int ret;
     468    ZZ_RECVFROM(__recvfrom_chk, (s, buf, len, buflen, flags, from, fromlen));
     469    return ret;
    463470}
    464471#endif
     
    483490#endif
    484491
    485 #define ZZ_READ(myread) \
     492#define ZZ_READ(myread, myargs) \
    486493    do \
    487494    { \
    488495        LOADSYM(myread); \
    489         ret = ORIG(read)(fd, buf, count); \
     496        ret = ORIG(myread) myargs; \
    490497        if(!_zz_ready || !_zz_iswatched(fd) || !_zz_hostwatched(fd) \
    491498             || _zz_islocked(fd) || !_zz_isactive(fd)) \
     
    513520ssize_t NEW(read)(int fd, void *buf, size_t count)
    514521{
    515     int ret; ZZ_READ(read); return (ssize_t)ret;
     522    int ret; ZZ_READ(read, (fd, buf, count)); return (ssize_t)ret;
    516523}
    517524#else
     
    519526int NEW(read)(int fd, void *buf, unsigned int count)
    520527{
    521     int ret; ZZ_READ(read); return ret;
     528    int ret; ZZ_READ(read, (fd, buf, count)); return ret;
    522529}
    523530#endif
     
    525532#if defined HAVE___READ_CHK
    526533#undef __read_chk
    527 ssize_t NEW(__read_chk)(int fd, void *buf, size_t count)
    528 {
    529     int ret; ZZ_READ(__read_chk); return (ssize_t)ret;
     534ssize_t NEW(__read_chk)(int fd, void *buf, size_t count, size_t buflen)
     535{
     536    int ret; ZZ_READ(__read_chk, (fd, buf, count, buflen)); return (ssize_t)ret;
    530537}
    531538#endif
  • zzuf/trunk/src/libzzuf/lib-stream.c

    r4373 r4375  
    115115#endif
    116116#if defined HAVE___FREAD_CHK
    117 static size_t  (*ORIG(__fread_chk))  (void *ptr, size_t size, size_t nmemb,
    118                                       FILE *stream);
     117static size_t  (*ORIG(__fread_chk))  (void *ptr, size_t ptrlen, size_t size,
     118                                      size_t nmemb, FILE *stream);
    119119#endif
    120120#if defined HAVE___FREAD_UNLOCKED_CHK
    121 static size_t  (*ORIG(__fread_unlocked_chk))  (void *ptr, size_t size,
    122                                               size_t nmemb, FILE *stream);
     121static size_t  (*ORIG(__fread_unlocked_chk)) (void *ptr, size_t ptrlen, size_t
     122                                              size, size_t nmemb, FILE *stream);
    123123#endif
    124124static int     (*ORIG(getc))     (FILE *stream);
     
    142142#endif
    143143#if defined HAVE___FGETS_CHK
    144 static char *  (*ORIG(__fgets_chk))    (char *s, int size, FILE *stream);
     144static char *  (*ORIG(__fgets_chk)) (char *s, size_t ptrlen,
     145                                     int size, FILE *stream);
    145146#endif
    146147#if defined HAVE___FGETS_UNLOCKED_CHK
    147 static char *  (*ORIG(__fgets_unlocked_chk)) (char *s, int size, FILE *stream);
     148static char *  (*ORIG(__fgets_unlocked_chk)) (char *s, size_t ptrlen,
     149                                              int size, FILE *stream);
    148150#endif
    149151static int     (*ORIG(ungetc))   (int c, FILE *stream);
     
    510512 */
    511513
    512 #define ZZ_FREAD(myfread) /* NEW */ \
     514#define ZZ_FREAD(myfread, myargs) /* NEW */ \
    513515    do \
    514516    { \
     
    521523        if(!_zz_ready || !_zz_iswatched(fd) || !_zz_isactive(fd) \
    522524             || _zz_islocked(fd)) \
    523             return ORIG(myfread)(ptr, size, nmemb, stream); \
     525            return ORIG(myfread) myargs; \
    524526        debug_stream("before", stream); \
    525527        /* FIXME: ftell() will return -1 on a pipe such as stdin */ \
     
    528530        oldcnt = get_stream_cnt(stream); \
    529531        _zz_lock(fd); \
    530         ret = ORIG(myfread)(ptr, size, nmemb, stream); \
     532        ret = ORIG(myfread) myargs; \
    531533        _zz_unlock(fd); \
    532534        newpos = ZZ_FTELL(stream); \
     
    559561size_t NEW(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
    560562{
    561     size_t ret; ZZ_FREAD(fread); return ret;
     563    size_t ret; ZZ_FREAD(fread, (ptr, size, nmemb, stream)); return ret;
    562564}
    563565
     
    566568size_t NEW(fread_unlocked)(void *ptr, size_t size, size_t nmemb, FILE *stream)
    567569{
    568     size_t ret; ZZ_FREAD(fread_unlocked); return ret;
     570    size_t ret;
     571    ZZ_FREAD(fread_unlocked, (ptr, size, nmemb, stream));
     572    return ret;
    569573}
    570574#endif
     
    572576#if defined HAVE___FREAD_CHK
    573577#undef __fread_chk
    574 size_t NEW(__fread_chk)(void *ptr, size_t size, size_t nmemb, FILE *stream)
    575 {
    576     size_t ret; ZZ_FREAD(__fread_chk); return ret;
     578size_t NEW(__fread_chk)(void *ptr, size_t ptrlen, size_t size, size_t nmemb,
     579                        FILE *stream)
     580{
     581    size_t ret;
     582    ZZ_FREAD(__fread_chk, (ptr, ptrlen, size, nmemb, stream));
     583    return ret;
    577584}
    578585#endif
     
    580587#if defined HAVE___FREAD_UNLOCKED_CHK
    581588#undef __fread_unlocked_chk
    582 size_t NEW(__fread_unlocked_chk)(void *ptr, size_t size, size_t nmemb,
    583                                  FILE *stream)
    584 {
    585     size_t ret; ZZ_FREAD(__fread_unlocked_chk); return ret;
     589size_t NEW(__fread_unlocked_chk)(void *ptr, size_t ptrlen, size_t size,
     590                                 size_t nmemb, FILE *stream)
     591{
     592    size_t ret;
     593    ZZ_FREAD(__fread_unlocked_chk, (ptr, ptrlen, size, nmemb, stream));
     594    return ret;
    586595}
    587596#endif
     
    691700 */
    692701
    693 #define ZZ_FGETS(myfgets, myfgetc) \
     702#define ZZ_FGETS(myfgets, myfgetc, myargs) \
    694703    do \
    695704    { \
     
    703712        if(!_zz_ready || !_zz_iswatched(fd) || !_zz_isactive(fd) \
    704713             || _zz_islocked(fd)) \
    705             return ORIG(myfgets)(s, size, stream); \
     714            return ORIG(myfgets) myargs; \
    706715        debug_stream("before", stream); \
    707716        oldpos = ZZ_FTELL(stream); \
     
    764773char *NEW(fgets)(char *s, int size, FILE *stream)
    765774{
    766     char *ret; ZZ_FGETS(fgets, fgetc); return ret;
     775    char *ret; ZZ_FGETS(fgets, fgetc, (s, size, stream)); return ret;
    767776}
    768777
     
    771780char *NEW(fgets_unlocked)(char *s, int size, FILE *stream)
    772781{
    773     char *ret; ZZ_FGETS(fgets_unlocked, fgetc_unlocked); return ret;
     782    char *ret;
     783    ZZ_FGETS(fgets_unlocked, fgetc_unlocked, (s, size, stream));
     784    return ret;
    774785}
    775786#endif
     
    777788#if defined HAVE___FGETS_CHK
    778789#undef __fgets_chk
    779 char *NEW(__fgets_chk)(char *s, int size, FILE *stream)
    780 {
    781     char *ret; ZZ_FGETS(__fgets_chk, fgetc); return ret;
     790char *NEW(__fgets_chk)(char *s, size_t ptrlen, int size, FILE *stream)
     791{
     792    char *ret;
     793    ZZ_FGETS(__fgets_chk, fgetc, (s, ptrlen, size, stream));
     794    return ret;
    782795}
    783796#endif
     
    785798#if defined HAVE___FGETS_UNLOCKED_CHK
    786799#undef __fgets_unlocked_chk
    787 char *NEW(__fgets_unlocked_chk)(char *s, int size, FILE *stream)
    788 {
    789     char *ret; ZZ_FGETS(__fgets_unlocked_chk, fgetc_unlocked); return ret;
     800char *NEW(__fgets_unlocked_chk)(char *s, size_t ptrlen, int size, FILE *stream)
     801{
     802    char *ret;
     803    ZZ_FGETS(__fgets_unlocked_chk, fgetc_unlocked, (s, ptrlen, size, stream));
     804    return ret;
    790805}
    791806#endif
Note: See TracChangeset for help on using the changeset viewer.