// Return 0 for OK, -1 for error, 1 for finished reading the file.
static int get_next_dindex(uint64_t **dnew, struct sbuf *sb, struct fzp *fzp)
{
static struct blk blk;
static struct iobuf rbuf;
memset(&rbuf, 0, sizeof(rbuf));
switch(iobuf_fill_from_fzp(&rbuf, fzp))
{
case -1: goto error;
case 1: return 1; // Reached the end.
}
if(rbuf.cmd==CMD_SAVE_PATH)
{
if(blk_set_from_iobuf_savepath(&blk, &rbuf))
goto error;
*dnew=(uint64_t *)malloc_w(sizeof(uint64_t), __func__);
**dnew=blk.savepath;
iobuf_free_content(&rbuf);
return 0;
}
else
iobuf_log_unexpected(&sb->path, __func__);
error:
iobuf_free_content(&rbuf);
return -1;
}
int run_bsigs(int argc, char *argv[])
{
int ret=1;
fzp *fzp=NULL;
struct iobuf rbuf;
struct blk blk;
memset(&rbuf, 0, sizeof(struct iobuf));
if(argc!=2)
return usage();
path=argv[1];
if(!(fzp=fzp_gzopen(path, "rb")))
goto end;
while(1)
{
iobuf_free_content(&rbuf);
switch(iobuf_fill_from_fzp(&rbuf, fzp))
{
case 1: ret=0; // Finished OK.
case -1: goto end; // Error.
}
if(parse_cmd(&rbuf, &blk)) goto end;
}
end:
iobuf_free_content(&rbuf);
fzp_close(&fzp);
return ret;
}
static void check_dindex(int i)
{
int ret;
struct fzp *fzp;
const char *p;
struct iobuf rbuf;
int lines=0;
struct blk blk;
uint64_t last_savepath=0;
p=get_extra_path(i, "dindex");
memset(&rbuf, 0, sizeof(rbuf));
fail_unless((fzp=fzp_gzopen(p, "rb"))!=NULL);
while(!(ret=iobuf_fill_from_fzp(&rbuf, fzp)))
{
lines++;
switch(rbuf.cmd)
{
case CMD_SAVE_PATH:
blk_set_from_iobuf_savepath(&blk, &rbuf);
fail_unless(blk.savepath>last_savepath);
last_savepath=blk.savepath;
break;
default:
fail_unless(0==1);
break;
}
iobuf_free_content(&rbuf);
}
fail_unless(ret==1);
fail_unless(lines>500);
fail_unless(!fzp_close(&fzp));
}
static int sbuf_fill(struct sbuf *sb, struct asfd *asfd, struct fzp *fzp,
struct blk *blk, struct cntr *cntr)
{
static struct iobuf *rbuf;
static struct iobuf localrbuf;
int ret=-1;
if(asfd) rbuf=asfd->rbuf;
else
{
// If not given asfd, use our own iobuf.
memset(&localrbuf, 0, sizeof(struct iobuf));
rbuf=&localrbuf;
}
while(1)
{
iobuf_free_content(rbuf);
if(fzp)
{
if((ret=iobuf_fill_from_fzp(rbuf, fzp)))
goto end;
}
else
{
if(asfd->read(asfd))
{
logp("error in async_read\n");
break;
}
}
switch(parse_cmd(sb, asfd, rbuf, blk, cntr))
{
case PARSE_RET_NEED_MORE:
continue;
case PARSE_RET_COMPLETE:
return 0;
case PARSE_RET_FINISHED:
ret=1;
goto end;
case PARSE_RET_ERROR:
default:
ret=-1;
goto end;
}
}
end:
iobuf_free_content(rbuf);
return ret;
}
static void check_hooks(int i, int fcount)
{
int ret;
struct fzp *fzp;
const char *p;
struct iobuf rbuf;
struct blk blk;
int lines=0;
uint64_t last_fingerprint=0;
char manifest_line[64]="";
p=get_extra_path(i, "hooks");
memset(&rbuf, 0, sizeof(rbuf));
snprintf(manifest_line, sizeof(manifest_line),
"%s/%08X", RMANIFEST_RELATIVE, i);
fail_unless((fzp=fzp_gzopen(p, "rb"))!=NULL);
while(!(ret=iobuf_fill_from_fzp(&rbuf, fzp)))
{
lines++;
switch(rbuf.cmd)
{
case CMD_MANIFEST:
fail_unless(lines==1);
ck_assert_str_eq(manifest_line, rbuf.buf);
break;
case CMD_FINGERPRINT:
blk_set_from_iobuf_fingerprint(&blk, &rbuf);
fail_unless(blk.fingerprint>last_fingerprint);
last_fingerprint=blk.fingerprint;
break;
default:
fail_unless(0==1);
break;
}
iobuf_free_content(&rbuf);
}
fail_unless(ret==1);
if(i<fcount-1)
fail_unless(lines>200);
else
fail_unless(lines>10); // Last file will have fewer entries.
fail_unless(!fzp_close(&fzp));
}
