int reverse_test() { char wbuf[1024]; char rbuf[1024]; printf("Reverse write test...\n"); for(int pass=1;pass<=2;pass++){ AFFILE *af = open_testfile("test_reverse",pass==1); for(int i=MAX_FMTS-1;i>=0;i--){ sprintf(wbuf,fmt,i); af_seek(af,strlen(wbuf)*i,SEEK_SET); if(pass==1){ if(af_write(af,(unsigned char *)wbuf,strlen(wbuf))!=(int)strlen(wbuf)){ err(1,"Attempt to write buffer %d failed\n",i); } } if(pass==2){ memset(rbuf,0,sizeof(rbuf)); if(af_read(af,(unsigned char *)rbuf,strlen(wbuf))!=(int)strlen(wbuf)){ err(1,"Attempt to read buffer %d failed\n",i); } if(strcmp(rbuf,wbuf)!=0){ errx(1,"Data doesn't verify.\nWrote: '%s'\nRead: '%s'\n",wbuf,rbuf); } } } af_close(af); } printf("\nReverse test passes.\n"); printf("======================\n\n"); return 0; }
int aff::vread(int fd, void *buff, unsigned int size) { int result; fdinfo* fi; AffNode* affNode = NULL; try { fi = this->__fdm->get(fd); affNode = dynamic_cast<AffNode* >(fi->node); } catch (...) { return (-1); } mutex_lock(&io_mutex); af_seek(affNode->affile, (int64_t)fi->offset, SEEK_SET); result = af_read(affNode->affile, (unsigned char*)buff, size); if (result > 0) fi->offset += result; mutex_unlock(&io_mutex); return (result); }
/* Note: The routine -assumes- we are under a lock on &(img_info->cache_lock)) */ static ssize_t aff_read(TSK_IMG_INFO * img_info, TSK_OFF_T offset, char *buf, size_t len) { ssize_t cnt; IMG_AFF_INFO *aff_info = (IMG_AFF_INFO *) img_info; if (tsk_verbose) tsk_fprintf(stderr, "aff_read: byte offset: %" PRIuOFF " len: %" PRIuOFF "\n", offset, len); if (offset > img_info->size) { tsk_error_reset(); tsk_error_set_errno(TSK_ERR_IMG_READ_OFF); tsk_error_set_errstr("aff_read - %" PRIuOFF, offset); return -1; } if (aff_info->seek_pos != offset) { if (af_seek(aff_info->af_file, offset, SEEK_SET) != offset) { tsk_error_reset(); // @@@ ADD more specific error messages tsk_error_set_errno(TSK_ERR_IMG_SEEK); tsk_error_set_errstr("aff_read - %" PRIuOFF " - %s", offset, strerror(errno)); return -1; } aff_info->seek_pos = offset; } cnt = af_read(aff_info->af_file, (unsigned char *) buf, len); if (cnt < 0) { // @@@ Add more specific error message tsk_error_reset(); tsk_error_set_errno(TSK_ERR_IMG_READ); tsk_error_set_errstr("aff_read - offset: %" PRIuOFF " - len: %" PRIuSIZE " - %s", offset, len, strerror(errno)); return -1; } /* AFF will return 0 if the page does not exist -- fill the * buffer with zeros in this case */ if (cnt == 0) { // @@@ We could improve this if there is an AFF call // to see if the data exists or not if ((af_eof(aff_info->af_file) == 0) && (offset + len < img_info->size)) { memset(buf, 0, len); cnt = len; } } aff_info->seek_pos += cnt; return cnt; }
void large_file_test() { int pagesize = 1024*1024; // megabyte sized segments int64_t num_segments = 5000; int64_t i; char fn[1024]; printf("Large file test... Creating a %"I64d"MB file...\n",pagesize*num_segments/(1024*1024)); filename(fn,sizeof(fn),"large_file"); AFFILE *af = af_open(fn,O_CREAT|O_RDWR|O_TRUNC,0666); unsigned char *buf = (unsigned char *)malloc(pagesize); memset(buf,'E', pagesize); af_enable_compression(af,opt_compression_type,opt_compression_level); af_set_pagesize(af,pagesize); af_set_maxsize(af,(int64_t)pagesize * 600); for(i=0;i<num_segments;i++){ sprintf((char *)buf,"%"I64d" page is put here",i); if(i%25==0) printf("\rWriting page %"I64d"\r",i); if(af_write(af,buf,pagesize)!=pagesize){ err(1,"Can't write page %"I64d,i); } } printf("\n\n"); /* Now let's just read some test locations */ for(i=0;i<num_segments;i+=num_segments/25){ // check a few places int r; af_seek(af,pagesize*i,SEEK_SET); r = af_read(af,buf,1024); // just read a bit if(r!=1024){ err(1,"Tried to read 1024 bytes; got %d\n",r); } if(atoi((char *)buf)!=i){ err(1,"at page %"I64d", expected %"I64d", got %s\n",i,i,buf); } printf("Page %"I64d" validates\n",i); } af_close(af); if(unlink("large_file.aff")){ err(1,"Can't delete large_file.aff"); } printf("Large file test passes\n"); }
int sequential_test() { char buf[1024]; const char *fmt = "this is line %d\n"; printf("Sequential test...\n"); AFFILE *af = open_testfile("test_sequential",1); for(int i=0;i<MAX_FMTS;i++){ if(i%250==0) printf("\rwriting %d/%d...",i,MAX_FMTS); sprintf(buf,fmt,i); if(af_write(af,(unsigned char *)buf,strlen(buf))!=(int)strlen(buf)){ err(1,"Attempt to write buffer %d failed\n",i); } } /* Test for a random bug that was reported */ af_update_seg(af,"test",0,(const u_char *)"foo",3); af_update_seg(af,"test",0,(const u_char *)"bar",3); af_del_seg(af,"test"); af_del_seg(af,"test"); af_close(af); printf("\nSequential file written.\n"); printf("\n"); printf("Now verifying the string...\n"); af = open_testfile("test_sequential",0); if(!af) err(1,"af_open"); for(int i=0;i<MAX_FMTS;i++){ char rbuf[1024]; sprintf(buf,fmt,i); int len = strlen(buf); if(af_read(af,(unsigned char *)rbuf,len)!=len){ err(1,"Attempt to read entry %d failed\n",i); } rbuf[len] = 0; // terminate the string if(strcmp(buf,rbuf)!=0){ err(1,"Attempt to verify entry %d failed.\nExpected: (len=%zd) '%s'\nGot: (len=%zd) '%s'\n", i,strlen(buf),buf,strlen(rbuf),rbuf); } } af_close(af); printf("===========================\n\n"); return 0; }
void readfile_test(const char *fname) { unsigned char buf[1024]; memset(buf,0,sizeof(buf)); AFFILE *af = af_open(fname,O_RDONLY,0666); if(!af){ af_perror(fname); err(1,"af_open(%s)",fname); } printf("using '%s'\n",af->v->name); printf("af_get_imagesize()=%"PRId64" errno=%d\n",af_get_imagesize(af),errno); int r = af_read(af,buf,sizeof(buf)); printf("af_read(af,buf,1024)=%d errno=%d\n",r,errno); r = fwrite(buf,1,512,stdout); assert(r==512); af_close(af); exit(0); }
static SSIZE_T aff_read_random(IMG_INFO * img_info, SSIZE_T vol_offset, char *buf, OFF_T len, OFF_T offset) { SSIZE_T cnt; IMG_AFF_INFO *aff_info = (IMG_AFF_INFO *) img_info; off_t tot_offset = offset + vol_offset; if (verbose) fprintf(stderr, "aff_read_random: byte offset: %" PRIuOFF " len: %" PRIuOFF "\n", offset, len); if (aff_info->seek_pos != tot_offset) { if ((off_t) af_seek(aff_info->af_file, tot_offset, SEEK_SET) != tot_offset) { // @@@ ADD more specific error messages tsk_errno = TSK_ERR_IMG_SEEK; snprintf(tsk_errstr, TSK_ERRSTR_L, "aff_read_random - %" PRIuOFF " - %s", tot_offset, strerror(errno)); tsk_errstr2[0] = '\0'; return -1; } aff_info->seek_pos = tot_offset; } cnt = af_read(aff_info->af_file, (unsigned char *) buf, len); if (cnt == -1) { // @@@ Add more specific error message tsk_errno = TSK_ERR_IMG_READ; snprintf(tsk_errstr, TSK_ERRSTR_L, "aff_read_random - offset: %" PRIuOFF " - len: %" PRIuOFF " - %s", tot_offset, len, strerror(errno)); tsk_errstr2[0] = '\0'; return -1; } aff_info->seek_pos += cnt; return cnt; }
static PyObject * affile_read(affile *self, PyObject *args, PyObject *kwds) { int written; PyObject *retdata; int readlen=-1; static char *kwlist[] = {"size", NULL}; if(!PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist, &readlen)) return NULL; if(readlen < 0 || readlen > self->size) readlen = self->size; retdata = PyString_FromStringAndSize(NULL, readlen); written = af_read(self->af, (unsigned char *)PyString_AsString(retdata), readlen); if(readlen != written) { return PyErr_Format(PyExc_IOError, "Failed to read all data: wanted %d, got %d", readlen, written); } return retdata; }
static int affuse_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi) { int res = 0; (void) fi; if(strcmp(path, raw_path) != 0){ return -ENOENT; } /* TODO: change to sector aligned readings to write NULLs to bad * blocks... */ /* looks like af_seek never fails */ af_seek(af_image, (uint64_t)offset, SEEK_SET); errno = 0; res = af_read(af_image, (unsigned char *)buf, (int)size); if (res<0){ if (errno==0) errno=-EIO; else res = -errno; } return res; }
void sparse_test() { printf("Sparse test...\n"); char buf[1024]; char fn[1024]; uint64_t mult = (uint64_t)3 * (uint64_t)1000000000; // 3GB in AFFILE *af = af_open(filename(fn,sizeof(fn),"sparse"),O_CREAT|O_RDWR|O_TRUNC,0666); af_enable_compression(af,opt_compression_type,opt_compression_level); af_set_maxsize(af,(int64_t)1024*1024*256); af_set_pagesize(af,1024*1024*16); for(u_int i=0;i<10;i++){ uint64_t pos = mult*i; memset(buf,0,sizeof(buf)); snprintf(buf,sizeof(buf),"This is at location=%"I64u"\n",pos); af_seek(af,pos,SEEK_SET); af_write(af,(unsigned char *)buf,sizeof(buf)); } /* Now verify */ for(u_int i=0;i<10;i++){ uint64_t pos = mult*i; uint64_t q; af_seek(af,pos,SEEK_SET); af_read(af,(unsigned char *)buf,sizeof(buf)); char *cc = strchr(buf,'='); if(!cc){ printf("Garbage read at location %"I64u"\n.",pos); exit(1); } if(sscanf(cc+1,"%"I64u,&q)!=1){ printf("Could not decode value at location %"I64u"(%s)\n",pos,cc+1); exit(1); } if(pos!=q){ printf("Wrong value at location %"I64u"; read %"I64u" in error.\n", pos,q); exit(1); } } /* Now seek to somewhere that no data has been written and see if we get 0s. */ memset(buf,'g',sizeof(buf)); af_seek(af,mult/2,SEEK_SET); ssize_t r = af_read(af,(unsigned char *)buf,sizeof(buf)); if(r!=sizeof(buf)){ err(1,"Tried to read %zd bytes at mult/2; got %zd bytes\n",sizeof(buf),r); } for(u_int i=0;i<sizeof(buf);i++){ if(buf[i]!=0) err(1,"data error; buf[%d]=%d\n",i,buf[i]); } /* Now try to read the last page in the file */ unsigned char big_buf[65536]; af_seek(af,9*mult,SEEK_SET); r = af_read(af,big_buf,sizeof(big_buf)); if(r!=sizeof(buf)){ errx(1,"Tried to read %zd bytes at the end of the file; got %zd bytes (should get %zd)", sizeof(big_buf),r,sizeof(buf)); } /* Now see if we can read past the end of the file */ af_seek(af,11*mult,SEEK_SET); r = af_read(af,(unsigned char *)buf,sizeof(buf)); if(r!=0) errx(1,"Tried to read past end of file; got %zd bytes (should get 0)",r); af_close(af); printf("\nSprase test passes.\n"); printf("=====================\n\n"); }
int random_read_test(int total_bytes,int data_page_size) { printf("\n\n\nrandom read test. filesize=%d, page_size=%d\n", total_bytes,data_page_size); /* Create a regular file and an AFF file */ printf("Creating random_contents.img and random_contents.%s, " "both with %d bytes of user data...\n", opt_ext,total_bytes); int fd = open("test_random_contents.img", O_CREAT|O_RDWR|O_TRUNC|O_BINARY,0666); if(fd<0) err(1,"fopen"); AFFILE *af = open_testfile("test_random_contents",1); /* Just write it out as one big write */ unsigned char *buf = (unsigned char *)malloc(total_bytes); unsigned char *buf2 = (unsigned char *)malloc(total_bytes); /* First half is random */ #ifdef HAVE_RAND_PSEUDO_BYTES RAND_pseudo_bytes(buf,total_bytes/2); #else for(int i=0;i<total_bytes/2;i++){ buf[i] = random(); } #endif /* Second half is a bit more predictable */ for(int i=total_bytes/2;i<total_bytes;i++){ buf[i] = ((i % 256) + (i / 256)) % 256; } if(write(fd,buf,total_bytes)!=total_bytes) err(1,"fwrite"); if(af_write(af,buf,total_bytes)!=(int)total_bytes) err(1,"af_write"); /* Now try lots of seeks and reads */ for(int i=0;i<MAX_FMTS;i++){ uint32_t loc = rand() % total_bytes; uint32_t len = rand() % total_bytes; memset(buf,0,total_bytes); memset(buf2,0,total_bytes); if(i%250==0) printf("\r#%d reading %"PRIu32" bytes at %"PRIu32" ...",i,loc,len); fflush(stdout); uint32_t l1 = (uint32_t)lseek(fd,loc,SEEK_SET); uint32_t l2 = (uint32_t)af_seek(af,loc,SEEK_SET); if(l1!=l2){ err(1,"l1 (%"PRIu32") != l2 (%"PRIu32")",l1,l2); } int r1 = read(fd,buf,len); int r2 = af_read(af,buf2,len); if(r1!=r2){ err(1,"r1 (%d) != r2 (%d)",r1,r2); } } af_close(af); close(fd); printf("\nRandom read test passes\n"); return 0; }
int random_write_test() { char buf[1024]; char *tally = (char *)calloc(MAX_FMTS,1); int i; memset(tally,0,sizeof(tally)); /* Create the AFF file */ sprintf(buf,fmt,0); // figure out how big fmt string is int fmt_size = strlen(buf); printf("Random write test...\n"); printf("Creating test file with %d byte records.\n", fmt_size); AFFILE *af = open_testfile("test_random",1); if(af_write(af,(unsigned char *)buf,fmt_size)!=fmt_size){ err(1,"af_write"); } for(i=0;i<MAX_FMTS;i++){ /* Find a random spot that's available */ int pos = rand() % MAX_FMTS; while(tally[pos]==1){ // if this one is used, find next pos = (pos + 1) % MAX_FMTS; } tally[pos] = 1; sprintf(buf,fmt,pos); assert((int)strlen(buf)==fmt_size); // make sure af_seek(af,fmt_size*pos,SEEK_SET); int wrote = af_write(af,(unsigned char *)buf,fmt_size); if(wrote !=fmt_size){ fprintf(stderr,"Attempt to write buffer #%d \n",pos); fprintf(stderr,"wrote %d bytes instead of %d bytes\n",wrote,fmt_size); exit(1); } if(i%250==0) printf("\r%d ...",i); fflush(stdout); } af_close(af); /* Now verify what was written */ printf("Verifying write test...\n"); af = open_testfile("test_random",0); for(i=0;i<MAX_FMTS;i++){ char should[256]; // what we should get sprintf(should,fmt,i); int got = af_read(af,(unsigned char *)buf,fmt_size); if(got != fmt_size){ fprintf(stderr,"Attempt to read %d bytes; got %d\n",fmt_size,got); exit(1); } if(i%250==24) printf("\r%d .. %d okay",i-24,i); } af_close(af); printf("\n"); printf("\nRandom write test passes.\n"); printf("======================\n"); return 0; }