static void setup_bad_read(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore :");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "ok");
asfd_mock_read(asfd, &r, -1, CMD_GEN, "blah");
}
static void setup_asfds_happy_path_one_blk_per_file_no_dedup_interrupt(
struct asfd *asfd, struct asfd *chfd, struct slist *slist)
{
int ar=0, aw=0, cr=0, cw=0;
setup_writes_from_slist(asfd, &aw, slist);
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read_no_op(asfd, &ar, 30);
setup_reads_from_slist(asfd, &ar, slist, 1, 2 /* interrupt */);
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "sigs_end");
setup_writes_from_slist_blk_requests(asfd,
&aw, slist, 1, 2 /* interrupt */);
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "blk_requests_end");
asfd_mock_read_no_op(asfd, &ar, 60);
setup_reads_from_slist_blks(asfd, &ar, slist, 1, 2 /* interrupt */);
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "backup_end");
setup_chfd_writes_from_slist(chfd, &cw, slist, 1, 2 /* interrupt */);
asfd_mock_read_no_op(chfd, &cr, 60);
setup_chfd_reads_from_slist_blks_not_got(chfd,
&cr, slist, 1, 2 /* interrupt */);
asfd_mock_read_no_op(chfd, &cr, 60);
asfd_assert_write(chfd, &cw, 0, CMD_GEN, "sigs_end");
}
static void setup_multiline_json(struct asfd *asfd)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "c:\n");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "\n{\n");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "\n\n\n");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "\n}\n");
}
static void setup_read_fail_2(struct asfd *asfd)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "hello:" VERSION);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "whoareyou");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "testclient");
asfd_mock_read(asfd, &r, -1, CMD_GEN, "okpassword");
}
static void setup_proto1_no_files(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore :");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "ok");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restoreend");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restoreend ok");
}
static void setup_simplest_json(struct asfd *csin, struct asfd *csout,
struct asfd *so_asfd)
{
int r=0; int w=0;
asfd_assert_write(csin, &w, 0, CMD_GEN, "c:\n");
asfd_mock_read(csin, &r, 0, CMD_GEN, "{}");
asfd_mock_read(csin, &r, -1, CMD_GEN, "blah");
}
END_TEST
static void setup_proto2_some_things(struct asfd *asfd, struct slist *slist)
{
struct sbuf *s;
struct stat statp_dir;
struct stat statp_file;
int r=0; int w=0;
fail_unless(!lstat(BASE, &statp_dir));
fail_unless(!lstat(BASE "/burp.conf", &statp_file));
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore :");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "ok");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restore_stream");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore_stream_ok");
for(s=slist->head; s; s=s->next)
{
s->winattr=0;
s->compression=0;
if(s->path.cmd==CMD_DIRECTORY)
{
memcpy(&s->statp, &statp_dir, sizeof(statp_dir));
attribs_encode(s);
}
if(sbuf_is_link(s))
{
char path[256];
if(s->path.cmd==CMD_HARD_LINK)
snprintf(path, sizeof(path), "%s", s->link.buf);
else
{
char *cp;
snprintf(path, sizeof(path), "%s", s->path.buf);
fail_unless((cp=strrchr(path, '/'))!=NULL);
cp++;
snprintf(cp, strlen(s->link.buf)+1, "%s",
s->link.buf);
}
build_file(path, NULL);
memcpy(&s->statp, &statp_file, sizeof(statp_file));
attribs_encode(s);
asfd_mock_read_iobuf(asfd, &r, 0, &s->attr);
asfd_mock_read_iobuf(asfd, &r, 0, &s->path);
asfd_mock_read_iobuf(asfd, &r, 0, &s->link);
}
else if(sbuf_is_filedata(s))
{
memcpy(&s->statp, &statp_file, sizeof(statp_file));
attribs_encode(s);
asfd_mock_read_iobuf(asfd, &r, 0, &s->attr);
asfd_mock_read_iobuf(asfd, &r,
0, &s->path);
asfd_mock_read(asfd, &r, 0, CMD_DATA, "data");
}
}
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restoreend");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restoreend ok");
}
static void setup_proto1_no_attribs(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore :");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "ok");
asfd_mock_read(asfd, &r, 0, CMD_DATAPTH, "datapth");
asfd_mock_read(asfd, &r, 0, CMD_FILE, BASE "/afile");
asfd_assert_write(asfd, &w, 0, CMD_ERROR, "read cmd with no attribs");
}
static void setup_proto1_no_datapth(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore :");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "ok");
asfd_mock_read(asfd, &r, 0, CMD_ATTRIBS, "attribs");
asfd_mock_read(asfd, &r, 0, CMD_FILE, BASE "/afile");
asfd_assert_write(asfd, &w, 0, CMD_ERROR, "datapth not supplied for f:utest_restore/afile in restore_switch_protocol1\n");
}
static void setup_asfds_proto2_interrupt(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
struct sbuf *s;
int count=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore_stream");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restore_stream_ok");
for(s=slist->head; s; s=s->next)
{
if(sbuf_is_link(s))
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
asfd_assert_write_iobuf(asfd, &w, 0, &s->link);
asfd_mock_read_no_op(asfd, &r, 1);
}
else if(sbuf_is_filedata(s))
{
struct blk *b;
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
asfd_mock_read_no_op(asfd, &r, 1);
if(count++==1)
{
asfd_assert_write(asfd,
&w, 0, CMD_DATA, "data");
asfd_assert_write(asfd,
&w, 0, CMD_DATA, "data");
asfd_mock_read_no_op(asfd, &r, 2);
asfd_mock_read(asfd, &r, 0, CMD_INTERRUPT,
s->path.buf);
asfd_assert_write(asfd, &w, 0,
CMD_END_FILE, "0:0");
continue;
}
for(b=s->protocol2->bstart;
b && b!=s->protocol2->bend; b=b->next)
{
asfd_assert_write(asfd,
&w, 0, CMD_DATA, "data");
asfd_mock_read_no_op(asfd, &r, 1);
}
asfd_assert_write(asfd, &w, 0, CMD_END_FILE, "0:0");
asfd_mock_read_no_op(asfd, &r, 1);
}
else
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
asfd_mock_read_no_op(asfd, &r, 1);
}
}
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restoreend");
asfd_mock_read_no_op(asfd, &r, 200);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restoreend_ok");
}
static void setup_multiline_json(struct asfd *csin, struct asfd *csout,
struct asfd *so_asfd)
{
int r=0; int w=0;
asfd_assert_write(csin, &w, 0, CMD_GEN, "c:\n");
asfd_mock_read(csin, &r, 0, CMD_GEN, "\n{\n");
asfd_mock_read(csin, &r, 0, CMD_GEN, "\n\n\n");
asfd_mock_read(csin, &r, 0, CMD_GEN, "\n}\n");
asfd_mock_read(csin, &r, -1, CMD_GEN, "blah");
}
static void setup_all_ok_server_version_empty(struct asfd *asfd)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "hello:" VERSION);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "whoareyou:");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "testclient");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "okpassword");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "password");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "ok");
}
static void setup_all_ok_version_warning_read_error(struct asfd *asfd)
{
int r=0; int w=0;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "hello:" VERSION);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "whoareyou:" VERSION);
asfd_assert_write(asfd, &w, 0, CMD_GEN, "testclient");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "okpassword");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "password");
asfd_mock_read(asfd, &r, 0, CMD_WARNING, "This is a version warning");
asfd_mock_read(asfd, &r, -1, CMD_GEN, "ok");
}
END_TEST
static void setup_asfds_empty(struct asfd *asfd, struct asfd *chfd,
struct slist *slist)
{
int ar=0, aw=0, cw=0;
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "sigs_end");
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "blk_requests_end");
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "backup_end");
asfd_assert_write(chfd, &cw, 0, CMD_GEN, "sigs_end");
}
static void setup_asfds_no_sigs_from_client(struct asfd *asfd,
struct asfd *chfd, struct slist *slist)
{
int ar=0, aw=0, cw=0;
setup_writes_from_slist(asfd, &aw, slist);
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read_no_op(asfd, &ar, 60);
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "sigs_end");
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "blk_requests_end");
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "backup_end");
asfd_assert_write(chfd, &cw, 0, CMD_GEN, "sigs_end");
}
static void setup_sfd_to_output(struct asfd *sfd,
struct asfd *in, struct asfd *out)
{
int a=0;
int r=0;
int w=0;
asfd_mock_read_no_op(in, &r, 3);
asfd_mock_read(sfd, &a, 0, CMD_GEN, "blah");
asfd_mock_read(sfd, &a, 0, CMD_GEN, "halb");
asfd_assert_write(out, &w, 0, CMD_GEN, "blah");
asfd_assert_write(out, &w, 0, CMD_GEN, "halb");
asfd_mock_read(sfd, &a, -1, CMD_GEN, "blah2");
}
static void setup_input_to_sfd(struct asfd *sfd,
struct asfd *in, struct asfd *out)
{
int r=0;
int ar=0;
int aw=0;
asfd_mock_read_no_op(sfd, &ar, 3);
asfd_mock_read(in, &r, 0, CMD_GEN, "blah");
asfd_mock_read(in, &r, 0, CMD_GEN, "halb");
asfd_assert_write(sfd, &aw, 0, CMD_GEN, "blah");
asfd_assert_write(sfd, &aw, 0, CMD_GEN, "halb");
asfd_mock_read(in, &r, -1, CMD_GEN, "blah2");
}
static void setup_read_error(struct asfd *csin, struct asfd *csout,
struct asfd *so_asfd)
{
int r=0; int w=0;
asfd_assert_write(csin, &w, 0, CMD_GEN, "c:\n");
asfd_mock_read(csin, &r, -1, CMD_GEN, "");
}
static void setup_bad_json(struct asfd *csin, struct asfd *csout,
struct asfd *so_asfd)
{
int r=0; int w=0;
asfd_assert_write(csin, &w, 0, CMD_GEN, "c:\n");
asfd_mock_read(csin, &r, 0, CMD_GEN, "{ adfdff }\n");
}
static void setup_asfds_read_error(struct asfd *asfd, struct asfd *chfd,
struct slist *slist)
{
int ar=0, aw=0;
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read(asfd, &ar, -1, CMD_DATA, "some data");
}
static void setup_in_error(struct asfd *sfd,
struct asfd *in, struct asfd *out)
{
int a=0;
int r=0;
asfd_mock_read_no_op(sfd, &a, 1);
asfd_mock_read(in, &r, -1, CMD_GEN, "blah");
}
static void setup_asfds_chfd_bad_cmd(struct asfd *asfd, struct asfd *chfd,
struct slist *slist)
{
int ar=0, aw=0, cr=0;
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read_no_op(asfd, &ar, 1);
asfd_mock_read(chfd, &cr, 0, CMD_MESSAGE, "some message");
}
static void setup_asfds_read_error_chfd(struct asfd *asfd, struct asfd *chfd,
struct slist *slist)
{
int ar=0, aw=0, cr=0;
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read_no_op(asfd, &ar, 1);
asfd_mock_read(chfd, &cr, -1, CMD_SIG, "some sig");
}
static void setup_asfds_proto1_stuff(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
struct sbuf *s;
for(s=slist->head; s; s=s->next)
{
if(sbuf_is_link(s))
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
asfd_assert_write_iobuf(asfd, &w, 0, &s->link);
}
else if(sbuf_is_filedata(s))
{
struct iobuf wbuf;
// The string "data" gzipped.
unsigned char gzipped_data1[10] = {
0x1f, 0x8b, 0x08, 0, 0,
0, 0, 0, 0x02, 0x03
};
unsigned char gzipped_data2[14] = {
0x4b, 0x49, 0x2c, 0x49, 0x04, 0x00, 0x63,
0xf3, 0xf3, 0xad, 0x04, 0x00, 0x00, 0x00
};
asfd_assert_write_iobuf(asfd, &w,
0, &s->protocol1->datapth);
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
if(sbuf_is_encrypted(s))
{
// Encrypted files get sent as is.
asfd_assert_write(asfd, &w, 0, CMD_APPEND,
"data");
asfd_assert_write(asfd, &w, 0, CMD_END_FILE,
"4:8d777f385d3dfec8815d20f7496026dc");
continue;
}
// Protocol1 always sends it gzipped.
iobuf_set(&wbuf, CMD_APPEND,
(char *)gzipped_data1, sizeof(gzipped_data1));
asfd_assert_write_iobuf(asfd, &w, 0, &wbuf);
iobuf_set(&wbuf, CMD_APPEND,
(char *)gzipped_data2, sizeof(gzipped_data2));
asfd_assert_write_iobuf(asfd, &w, 0, &wbuf);
asfd_assert_write(asfd, &w, 0, CMD_END_FILE,
"4:8d777f385d3dfec8815d20f7496026dc");
}
else
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
}
}
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restoreend");
asfd_mock_read_no_op(asfd, &r, 100);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restoreend_ok");
}
static void setup_asfds_proto2_interrupt_on_non_filedata(struct asfd *asfd,
struct slist *slist)
{
int r=0; int w=0;
struct sbuf *s;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore_stream");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restore_stream_ok");
for(s=slist->head; s; s=s->next)
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
}
asfd_mock_read_no_op(asfd, &r, 1);
asfd_mock_read(asfd, &r, 0, CMD_INTERRUPT, "00000");
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restoreend");
asfd_mock_read_no_op(asfd, &r, 200);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restoreend_ok");
}
static void setup_ncurses_input_size_error(struct asfd *csin,
struct asfd *csout,
struct asfd *nin, struct asfd *so_asfd)
{
int r=0; int w=0;
int nr=0;
asfd_mock_read(nin, &nr, 0, CMD_GEN, "Q");
asfd_mock_read_no_op(csin, &r, 1);
asfd_assert_write(csin, &w, 0, CMD_GEN, "c:\n");
}
static void setup_asfds_write_error_chfd(struct asfd *asfd, struct asfd *chfd,
struct slist *slist)
{
int ar=0, aw=0, cw=0;
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "sigs_end");
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "blk_requests_end");
asfd_assert_write(chfd, &cw, -1, CMD_GEN, "sigs_end");
}
static void setup_asfds_happy_path_three_blks_per_file_full_dedup(
struct asfd *asfd, struct asfd *chfd, struct slist *slist)
{
int ar=0, aw=0, cr=0, cw=0;
setup_writes_from_slist(asfd, &aw, slist);
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "requests_end");
asfd_mock_read_no_op(asfd, &ar, 200);
setup_reads_from_slist(asfd, &ar, slist, 3, 0);
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "sigs_end");
asfd_assert_write(asfd, &aw, 0, CMD_GEN, "blk_requests_end");
asfd_mock_read_no_op(asfd, &ar, 1000);
asfd_mock_read(asfd, &ar, 0, CMD_GEN, "backup_end");
setup_chfd_writes_from_slist(chfd, &cw, slist, 3, 0);
asfd_mock_read_no_op(chfd, &cr, 1000);
setup_chfd_reads_from_slist_blks_got(chfd, &cr, slist, 3, 0);
asfd_mock_read_no_op(chfd, &cr, 1000);
asfd_assert_write(chfd, &cw, 0, CMD_GEN, "sigs_end");
}
static void setup_reads_from_slist(struct asfd *asfd,
int *ar, struct slist *slist, int number_of_blks, uint64_t interrupt)
{
int file_no=1;
struct sbuf *s;
struct blk blk;
struct iobuf iobuf;
if(!slist) return;
for(s=slist->head; s; s=s->next)
{
if(sbuf_is_filedata(s)
&& !sbuf_is_encrypted(s)) // Not working for proto2 yet.
{
int b;
s->protocol2->index=file_no++;
if(interrupt==s->protocol2->index)
{
char buf[32]="";
asfd_mock_read(asfd,
ar, 0, CMD_WARNING, "path vanished\n");
base64_from_uint64(interrupt, buf);
asfd_mock_read(asfd, ar, 0, CMD_INTERRUPT,
buf);
continue;
}
iobuf_free_content(&s->attr);
attribs_encode(s);
asfd_mock_read(asfd,
ar, 0, CMD_ATTRIBS_SIGS, s->attr.buf);
blk.fingerprint=file_no;
memset(&blk.md5sum, file_no, MD5_DIGEST_LENGTH);
blk_to_iobuf_sig(&blk, &iobuf);
for(b=0; b<number_of_blks; b++)
asfd_mock_read_iobuf(asfd, ar, 0, &iobuf);
}
}
}
END_TEST
static void setup_asfds_proto2_stuff(struct asfd *asfd, struct slist *slist)
{
int r=0; int w=0;
struct sbuf *s;
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restore_stream");
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restore_stream_ok");
for(s=slist->head; s; s=s->next)
{
if(sbuf_is_link(s))
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
asfd_assert_write_iobuf(asfd, &w, 0, &s->link);
}
else if(sbuf_is_filedata(s))
{
struct blk *b;
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
for(b=s->protocol2->bstart;
b && b!=s->protocol2->bend; b=b->next)
asfd_assert_write(asfd,
&w, 0, CMD_DATA, "data");
asfd_assert_write(asfd, &w, 0, CMD_END_FILE, "0:0");
}
else
{
asfd_assert_write_iobuf(asfd, &w, 0, &s->attr);
asfd_assert_write_iobuf(asfd, &w, 0, &s->path);
}
}
asfd_assert_write(asfd, &w, 0, CMD_GEN, "restoreend");
asfd_mock_read_no_op(asfd, &r, 300);
asfd_mock_read(asfd, &r, 0, CMD_GEN, "restoreend_ok");
}
