Changeset 1523
- Timestamp:
- Dec 28, 2006, 9:22:32 PM (16 years ago)
- Location:
- zzuf/trunk/src
- Files:
-
- 11 edited
Legend:
- Unmodified
- Added
- Removed
-
zzuf/trunk/src/debug.c
r1504 r1523 31 31 #include "debug.h" 32 32 33 extern int _zz uf_debug;33 extern int _zz_hasdebug; 34 34 35 void zzuf_debug(const char *format, ...)35 void _zz_debug(const char *format, ...) 36 36 { 37 37 va_list args; 38 38 int saved_errno; 39 39 40 if(!_zz uf_debug)40 if(!_zz_hasdebug) 41 41 return; 42 42 -
zzuf/trunk/src/debug.h
r1480 r1523 17 17 */ 18 18 19 extern void zzuf_debug(const char *format, ...)19 extern void _zz_debug(const char *format, ...) 20 20 __attribute__((__format__(__printf__, 1, 2))); 21 21 22 #define debug zzuf_debug22 #define debug _zz_debug 23 23 -
zzuf/trunk/src/fuzz.c
r1520 r1523 36 36 #define MAGIC2 0x783bc31f 37 37 38 void zzuf_fuzz(int fd, uint8_t *buf, uint64_t len)38 void _zz_fuzz(int fd, uint8_t *buf, uint64_t len) 39 39 { 40 40 uint64_t start, stop; … … 60 60 61 61 /* Add some random dithering to handle ratio < 1.0/CHUNKBYTES */ 62 zzuf_srand(_zzuf_seed ^ chunkseed);63 todo = (int)((_zz uf_ratio * (8 * CHUNKBYTES * 1000)64 + zzuf_rand(1000)) / 1000.0);65 zzuf_srand(_zzuf_seed ^ chunkseed ^ (todo * MAGIC2));62 _zz_srand(_zz_seed ^ chunkseed); 63 todo = (int)((_zz_ratio * (8 * CHUNKBYTES * 1000) 64 + _zz_rand(1000)) / 1000.0); 65 _zz_srand(_zz_seed ^ chunkseed ^ (todo * MAGIC2)); 66 66 67 67 while(todo--) 68 68 { 69 unsigned int idx = zzuf_rand(CHUNKBYTES);70 uint8_t byte = (1 << zzuf_rand(8));69 unsigned int idx = _zz_rand(CHUNKBYTES); 70 uint8_t byte = (1 << _zz_rand(8)); 71 71 72 72 fuzz->data[idx] ^= byte; -
zzuf/trunk/src/fuzz.h
r1470 r1523 17 17 */ 18 18 19 extern void zzuf_fuzz(int, uint8_t *, uint64_t);19 extern void _zz_fuzz(int, uint8_t *, uint64_t); 20 20 -
zzuf/trunk/src/libzzuf.c
r1520 r1523 39 39 40 40 /* Global variables */ 41 int _zzuf_ready = 0; 42 int _zzuf_debug = 0; 43 int _zzuf_seed = 0; 44 float _zzuf_ratio = 0.004f; 45 regex_t * _zzuf_include = NULL; 46 regex_t * _zzuf_exclude = NULL; 47 48 #define MAXFD 1024 49 struct zzuf 41 int _zz_ready = 0; 42 int _zz_hasdebug = 0; 43 int _zz_seed = 0; 44 float _zz_ratio = 0.004f; 45 regex_t * _zz_include = NULL; 46 regex_t * _zz_exclude = NULL; 47 48 /* Library initialisation shit */ 49 void _zz_init(void) 50 { 51 char *tmp; 52 53 tmp = getenv("ZZUF_DEBUG"); 54 if(tmp && *tmp) 55 _zz_hasdebug = 1; 56 57 tmp = getenv("ZZUF_SEED"); 58 if(tmp && *tmp) 59 _zz_seed = atol(tmp); 60 61 tmp = getenv("ZZUF_RATIO"); 62 if(tmp && *tmp) 63 _zz_ratio = atof(tmp); 64 if(_zz_ratio < 0.0f) 65 _zz_ratio = 0.0f; 66 else if(_zz_ratio > 5.0f) 67 _zz_ratio = 5.0f; 68 69 tmp = getenv("ZZUF_INCLUDE"); 70 if(tmp && *tmp) 71 { 72 _zz_include = malloc(sizeof(*_zz_include)); 73 regcomp(_zz_include, tmp, 0); 74 } 75 76 tmp = getenv("ZZUF_EXCLUDE"); 77 if(tmp && *tmp) 78 { 79 _zz_exclude = malloc(sizeof(*_zz_exclude)); 80 regcomp(_zz_exclude, tmp, 0); 81 } 82 83 zfd_init(); 84 85 _zz_load_fd(); 86 _zz_load_stream(); 87 88 _zz_ready = 1; 89 90 debug("libzzuf initialised"); 91 } 92 93 /* Deinitialisation */ 94 void _zz_fini(void) 95 { 96 zfd_fini(); 97 } 98 99 /* File descriptor stuff */ 100 struct files 50 101 { 51 102 int managed; … … 55 106 struct fuzz fuzz; 56 107 } 57 files[MAXFD]; 58 59 /* Library initialisation shit */ 60 void zzuf_init(void) 61 { 62 char *tmp; 108 *files; 109 110 int *fds; 111 112 int maxfd, nfiles; 113 114 void zfd_init(void) 115 { 116 files = NULL; 117 nfiles = 0; 118 119 /* Start with one fd in the lookup table */ 120 fds = malloc(1 * sizeof(int)); 121 for(maxfd = 0; maxfd < 1; maxfd++) 122 fds[maxfd] = -1; 123 } 124 125 void zfd_fini(void) 126 { 63 127 int i; 64 128 65 tmp = getenv("ZZUF_DEBUG"); 66 if(tmp && *tmp) 67 _zzuf_debug = 1; 68 69 tmp = getenv("ZZUF_SEED"); 70 if(tmp && *tmp) 71 _zzuf_seed = atol(tmp); 72 73 tmp = getenv("ZZUF_RATIO"); 74 if(tmp && *tmp) 75 _zzuf_ratio = atof(tmp); 76 if(_zzuf_ratio < 0.0f) 77 _zzuf_ratio = 0.0f; 78 else if(_zzuf_ratio > 5.0f) 79 _zzuf_ratio = 5.0f; 80 81 tmp = getenv("ZZUF_INCLUDE"); 82 if(tmp && *tmp) 83 { 84 _zzuf_include = malloc(sizeof(*_zzuf_include)); 85 regcomp(_zzuf_include, tmp, 0); 86 } 87 88 tmp = getenv("ZZUF_EXCLUDE"); 89 if(tmp && *tmp) 90 { 91 _zzuf_exclude = malloc(sizeof(*_zzuf_exclude)); 92 regcomp(_zzuf_exclude, tmp, 0); 93 } 94 95 for(i = 0; i < MAXFD; i++) 96 files[i].managed = 0; 97 98 zzuf_load_fd(); 99 zzuf_load_stream(); 100 101 _zzuf_ready = 1; 102 103 debug("libzzuf initialised"); 104 } 105 106 /* Deinitialisation */ 107 void zzuf_fini(void) 108 { 109 int i; 110 111 for(i = 0; i < MAXFD; i++) 112 { 113 if(!files[i].managed) 129 for(i = 0; i < maxfd; i++) 130 { 131 if(!files[fds[i]].managed) 114 132 continue; 115 133 … … 117 135 * closed properly, there's a leak, but it's not our problem. */ 118 136 } 119 } 120 121 /* fd stuff */ 137 138 free(files); 139 free(fds); 140 } 141 122 142 int zfd_ismanaged(int fd) 123 143 { 124 return files[fd].managed; 125 } 126 127 void zfd_manage(int fd) 128 { 129 files[fd].managed = 1; 130 files[fd].pos = 0; 131 files[fd].fuzz.cur = -1; 132 files[fd].fuzz.data = malloc(CHUNKBYTES); 133 } 134 135 void zfd_unmanage(int fd) 136 { 137 files[fd].managed = 0; 138 free(files[fd].fuzz.data); 144 if(fd < 0 || fd >= maxfd || fds[fd] == -1) 145 return 0; 146 147 return 1; 148 } 149 150 void zfd_register(int fd) 151 { 152 int i; 153 154 if(fd < 0 || fd > 65535 || (fd < maxfd && fds[fd] != -1)) 155 return; 156 157 while(fd >= maxfd) 158 { 159 fds = realloc(fds, 2 * maxfd * sizeof(int)); 160 for(i = maxfd; i < maxfd * 2; i++) 161 fds[i] = -1; 162 maxfd *= 2; 163 } 164 165 /* Find an empty slot */ 166 for(i = 0; i < nfiles; i++) 167 if(files[i].managed == 0) 168 break; 169 170 /* No slot found, allocate memory */ 171 if(i == nfiles) 172 { 173 nfiles++; 174 files = realloc(files, nfiles * sizeof(struct files)); 175 } 176 177 files[i].managed = 1; 178 files[i].pos = 0; 179 files[i].fuzz.cur = -1; 180 files[i].fuzz.data = malloc(CHUNKBYTES); 181 182 fds[fd] = i; 183 } 184 185 void zfd_unregister(int fd) 186 { 187 if(fd < 0 || fd >= maxfd || fds[fd] == -1) 188 return; 189 190 files[fds[fd]].managed = 0; 191 free(files[fds[fd]].fuzz.data); 192 193 fds[fd] = -1; 139 194 } 140 195 141 196 long int zfd_getpos(int fd) 142 197 { 143 return files[fd].pos; 198 if(fd < 0 || fd >= maxfd || fds[fd] == -1) 199 return 0; 200 201 return files[fds[fd]].pos; 144 202 } 145 203 146 204 void zfd_setpos(int fd, long int pos) 147 205 { 148 files[fd].pos = pos; 206 if(fd < 0 || fd >= maxfd || fds[fd] == -1) 207 return; 208 209 files[fds[fd]].pos = pos; 149 210 } 150 211 151 212 void zfd_addpos(int fd, long int off) 152 213 { 153 files[fd].pos += off; 214 if(fd < 0 || fd >= maxfd || fds[fd] == -1) 215 return; 216 217 files[fds[fd]].pos += off; 154 218 } 155 219 156 220 struct fuzz *zfd_getfuzz(int fd) 157 221 { 158 return &files[fd].fuzz; 159 } 160 222 if(fd < 0 || fd >= maxfd || fds[fd] == -1) 223 return NULL; 224 225 return &files[fds[fd]].fuzz; 226 } 227 -
zzuf/trunk/src/libzzuf.h
r1520 r1523 30 30 31 31 /* Internal variables */ 32 extern int _zz uf_ready;33 extern int _zz uf_debug;34 extern int _zz uf_seed;35 extern float _zz uf_ratio;36 extern regex_t * _zz uf_include;37 extern regex_t * _zz uf_exclude;32 extern int _zz_ready; 33 extern int _zz_hasdebug; 34 extern int _zz_seed; 35 extern float _zz_ratio; 36 extern regex_t * _zz_include; 37 extern regex_t * _zz_exclude; 38 38 39 39 /* Library initialisation shit */ 40 extern void zzuf_init(void) __attribute__((constructor));41 extern void zzuf_fini(void) __attribute__((destructor));40 extern void _zz_init(void) __attribute__((constructor)); 41 extern void _zz_fini(void) __attribute__((destructor)); 42 42 43 43 /* File descriptor handling */ 44 extern void zfd_init(void); 45 extern void zfd_fini(void); 44 46 extern int zfd_ismanaged(int); 45 extern void zfd_ manage(int);46 extern void zfd_un manage(int);47 extern void zfd_register(int); 48 extern void zfd_unregister(int); 47 49 extern long int zfd_getpos(int); 48 50 extern void zfd_setpos(int, long int); -
zzuf/trunk/src/load-fd.c
r1522 r1523 51 51 static int (*close_orig) (int fd); 52 52 53 void zzuf_load_fd(void)53 void _zz_load_fd(void) 54 54 { 55 55 LOADSYM(open); … … 65 65 { \ 66 66 int mode = 0; \ 67 if(!_zz uf_ready) \67 if(!_zz_ready) \ 68 68 LOADSYM(fn); \ 69 69 if(oflag & O_CREAT) \ … … 79 79 ret = ORIG(fn)(file, oflag); \ 80 80 } \ 81 if(!_zz uf_ready) \81 if(!_zz_ready) \ 82 82 return ret; \ 83 83 if(ret >= 0 \ 84 84 && ((oflag & (O_RDONLY | O_RDWR | O_WRONLY)) != O_WRONLY)) \ 85 85 { \ 86 if(_zz uf_include && \87 regexec(_zz uf_include, file, 0, NULL, 0) == REG_NOMATCH) \86 if(_zz_include && \ 87 regexec(_zz_include, file, 0, NULL, 0) == REG_NOMATCH) \ 88 88 /* not included: ignore */ ; \ 89 else if(_zz uf_exclude && \90 regexec(_zz uf_exclude, file, 0, NULL, 0) != REG_NOMATCH) \89 else if(_zz_exclude && \ 90 regexec(_zz_exclude, file, 0, NULL, 0) != REG_NOMATCH) \ 91 91 /* excluded: ignore */ ; \ 92 92 else \ … … 97 97 else \ 98 98 debug(STR(fn) "(\"%s\", %i) = %i", file, oflag, ret); \ 99 zfd_ manage(ret); \99 zfd_register(ret); \ 100 100 } \ 101 101 } \ … … 116 116 int ret; 117 117 118 if(!_zz uf_ready)118 if(!_zz_ready) 119 119 LOADSYM(read); 120 120 ret = read_orig(fd, buf, count); 121 if(!_zz uf_ready || !zfd_ismanaged(fd))121 if(!_zz_ready || !zfd_ismanaged(fd)) 122 122 return ret; 123 123 … … 125 125 if(ret > 0) 126 126 { 127 zzuf_fuzz(fd, buf, ret);127 _zz_fuzz(fd, buf, ret); 128 128 zfd_addpos(fd, ret); 129 129 } … … 138 138 #define LSEEK(fn, off_t) \ 139 139 do { \ 140 if(!_zz uf_ready) \140 if(!_zz_ready) \ 141 141 LOADSYM(fn); \ 142 142 ret = ORIG(fn)(fd, offset, whence); \ 143 if(!_zz uf_ready || !zfd_ismanaged(fd)) \143 if(!_zz_ready || !zfd_ismanaged(fd)) \ 144 144 return ret; \ 145 145 debug(STR(fn)"(%i, %lli, %i) = %lli", \ … … 167 167 int ret; 168 168 169 if(!_zz uf_ready)169 if(!_zz_ready) 170 170 LOADSYM(close); 171 171 ret = close_orig(fd); 172 if(!_zz uf_ready || !zfd_ismanaged(fd))172 if(!_zz_ready || !zfd_ismanaged(fd)) 173 173 return ret; 174 174 175 175 debug("close(%i) = %i", fd, ret); 176 zfd_un manage(fd);176 zfd_unregister(fd); 177 177 178 178 return ret; -
zzuf/trunk/src/load-stream.c
r1522 r1523 56 56 FILE *stream); 57 57 58 void zzuf_load_stream(void)58 void _zz_load_stream(void) 59 59 { 60 60 LOADSYM(fopen); … … 77 77 do \ 78 78 { \ 79 if(!_zz uf_ready) \79 if(!_zz_ready) \ 80 80 { \ 81 81 LOADSYM(fn); \ … … 85 85 if(ret) \ 86 86 { \ 87 if(_zz uf_include && \88 regexec(_zz uf_include, path, 0, NULL, 0) == REG_NOMATCH) \87 if(_zz_include && \ 88 regexec(_zz_include, path, 0, NULL, 0) == REG_NOMATCH) \ 89 89 /* not included: ignore */ ; \ 90 else if(_zz uf_exclude && \91 regexec(_zz uf_exclude, path, 0, NULL, 0) != REG_NOMATCH) \90 else if(_zz_exclude && \ 91 regexec(_zz_exclude, path, 0, NULL, 0) != REG_NOMATCH) \ 92 92 /* excluded: ignore */ ; \ 93 93 else \ 94 94 { \ 95 95 int fd = fileno(ret); \ 96 zfd_ manage(fd); \96 zfd_register(fd); \ 97 97 debug(STR(fn) "(\"%s\", \"%s\") = %p", path, mode, ret); \ 98 98 } \ … … 114 114 int ret, fd; 115 115 116 if(!_zz uf_ready)116 if(!_zz_ready) 117 117 LOADSYM(fseek); 118 118 fd = fileno(stream); 119 if(!_zz uf_ready || !zfd_ismanaged(fd))119 if(!_zz_ready || !zfd_ismanaged(fd)) 120 120 return fseek_orig(stream, offset, whence); 121 121 … … 146 146 int fd; 147 147 148 if(!_zz uf_ready)148 if(!_zz_ready) 149 149 LOADSYM(fread); 150 150 fd = fileno(stream); 151 if(!_zz uf_ready || !zfd_ismanaged(fd))151 if(!_zz_ready || !zfd_ismanaged(fd)) 152 152 return fread_orig(ptr, size, nmemb, stream); 153 153 … … 161 161 * a partial read may have advanced the stream pointer */ 162 162 long int newpos = ftell(stream); 163 zzuf_fuzz(fd, ptr, newpos - pos);163 _zz_fuzz(fd, ptr, newpos - pos); 164 164 zfd_setpos(fd, newpos); 165 165 } … … 170 170 do { \ 171 171 int fd; \ 172 if(!_zz uf_ready) \172 if(!_zz_ready) \ 173 173 LOADSYM(fn); \ 174 174 fd = fileno(stream); \ 175 if(!_zz uf_ready || !zfd_ismanaged(fd)) \175 if(!_zz_ready || !zfd_ismanaged(fd)) \ 176 176 return ORIG(fn)(stream); \ 177 177 ret = ORIG(fn)(stream); \ … … 179 179 { \ 180 180 uint8_t ch = ret; \ 181 zzuf_fuzz(fd, &ch, 1); \181 _zz_fuzz(fd, &ch, 1); \ 182 182 zfd_addpos(fd, 1); \ 183 183 ret = ch; \ … … 201 201 int i, fd; 202 202 203 if(!_zz uf_ready)203 if(!_zz_ready) 204 204 LOADSYM(fgets); 205 205 fd = fileno(stream); 206 if(!_zz uf_ready || !zfd_ismanaged(fd))206 if(!_zz_ready || !zfd_ismanaged(fd)) 207 207 return fgets_orig(s, size, stream); 208 208 … … 225 225 } 226 226 s[i] = (char)(unsigned char)ch; 227 zzuf_fuzz(fd, (uint8_t *)s + i, 1); /* rather inefficient */227 _zz_fuzz(fd, (uint8_t *)s + i, 1); /* rather inefficient */ 228 228 zfd_addpos(fd, 1); 229 229 if(s[i] == '\n') … … 244 244 int ret, fd; 245 245 246 if(!_zz uf_ready)246 if(!_zz_ready) 247 247 LOADSYM(ungetc); 248 248 fd = fileno(stream); 249 if(!_zz uf_ready || !zfd_ismanaged(fd))249 if(!_zz_ready || !zfd_ismanaged(fd)) 250 250 return ungetc_orig(c, stream); 251 251 252 252 zfd_addpos(fd, -1); 253 zzuf_fuzz(fd, &ch, 1);253 _zz_fuzz(fd, &ch, 1); 254 254 ret = ungetc_orig((int)ch, stream); 255 255 if(ret >= 0) … … 265 265 int ret, fd; 266 266 267 if(!_zz uf_ready)267 if(!_zz_ready) 268 268 LOADSYM(fclose); 269 269 fd = fileno(fp); 270 if(!_zz uf_ready || !zfd_ismanaged(fd))270 if(!_zz_ready || !zfd_ismanaged(fd)) 271 271 return fclose_orig(fp); 272 272 273 273 ret = fclose_orig(fp); 274 274 debug("fclose(%p) = %i", fp, ret); 275 zfd_un manage(fd);275 zfd_unregister(fd); 276 276 277 277 return ret; … … 283 283 ssize_t done, size; \ 284 284 int fd, finished = 0; \ 285 if(!_zz uf_ready) \285 if(!_zz_ready) \ 286 286 LOADSYM(fn); \ 287 287 fd = fileno(stream); \ 288 if(!_zz uf_ready || !zfd_ismanaged(fd)) \288 if(!_zz_ready || !zfd_ismanaged(fd)) \ 289 289 return getdelim_orig(lineptr, n, delim, stream); \ 290 290 line = *lineptr; \ … … 312 312 { \ 313 313 unsigned char c = ch; \ 314 zzuf_fuzz(fd, &c, 1); /* even more inefficient */ \314 _zz_fuzz(fd, &c, 1); /* even more inefficient */ \ 315 315 line[done++] = c; \ 316 316 zfd_addpos(fd, 1); \ -
zzuf/trunk/src/load.h
r1494 r1523 27 27 } while(0) 28 28 29 extern void zzuf_load_fd(void);30 extern void zzuf_load_stream(void);29 extern void _zz_load_fd(void); 30 extern void _zz_load_stream(void); 31 31 -
zzuf/trunk/src/random.c
r1484 r1523 28 28 #include "random.h" 29 29 30 void zzuf_srand(uint32_t seed)30 void _zz_srand(uint32_t seed) 31 31 { 32 32 srand(seed ^ 0x12345678); 33 33 } 34 34 35 uint32_t zzuf_rand(uint32_t max)35 uint32_t _zz_rand(uint32_t max) 36 36 { 37 37 if(max <= RAND_MAX) -
zzuf/trunk/src/random.h
r1484 r1523 17 17 */ 18 18 19 void zzuf_srand(uint32_t);20 uint32_t zzuf_rand(uint32_t);19 void _zz_srand(uint32_t); 20 uint32_t _zz_rand(uint32_t); 21 21
Note: See TracChangeset
for help on using the changeset viewer.