static void
test_parse_partial_str(StateWrapper *wrapper, gconstpointer user_data)
{
guchar buffer[] = { 0x00, 0x0e, 0x00, 0x73, 0x6f, 0x6f, 0x73, 0x68, 0x69, 0x20 };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = VAL_STR;
// First run should return NULL and not remove any bytes from the byte array
gulong byte_array_size = wrapper->state->buffer->len;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_null(node->value);
g_assert_cmpuint(byte_array_size, ==, wrapper->state->buffer->len);
guchar buffer2[] = { 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67 };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer2, sizeof(buffer2));
// Second run should now be able to succesfully parse the string
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_STRING));
g_assert_cmpstr(g_variant_get_string(node->value, NULL), ==, "sooshi testing");
guchar buffer3[16];
gint length = sooshi_node_value_to_bytes(node, buffer3);
g_assert_cmpint(length, ==, sizeof(buffer3));
g_assert_cmpmem(buffer3, sizeof(buffer) - 1, buffer + 1, sizeof(buffer) - 1);
g_assert_cmpmem(buffer3 + sizeof(buffer) - 1, sizeof(buffer3) - (sizeof(buffer) - 1), buffer2, sizeof(buffer2));
g_free(node);
}
static void
test_parse_flt(StateWrapper *wrapper, gconstpointer user_data)
{
float real_value = 12.3456789;
guchar buffer[] = { 0x00,
((guchar*)&real_value)[0],
((guchar*)&real_value)[1],
((guchar*)&real_value)[2],
((guchar*)&real_value)[3],
};
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = VAL_FLT;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_DOUBLE));
g_assert_cmpfloat(g_variant_get_double(node->value), ==, real_value);
guchar buffer2[4];
gint length = sooshi_node_value_to_bytes(node, buffer2);
g_assert_cmpint(length, ==, sizeof(buffer2));
g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1);
g_free(node);
}
static void test_set_rock_blocks(void) {
const int shape[2] = {10, 20};
double **z = (double**)malloc(sizeof(double*) * shape[0]);
char **rock_type = (char**)malloc(sizeof(char*) * shape[0]);
int i;
char expected[20] = {
'f', 'f', 's', 's', 's',
'f', 'f', 's', 's', 's', 'f', 'f', 's', 's', 's',
'f', 'f', 's', 's', 's'
};
z[0] = (double*)malloc(sizeof(double) * shape[0] * shape[1]);
rock_type[0] = (char*)malloc(sizeof(char) * shape[0] * shape[1]);
for (i=1; i < shape[0]; i++) {
z[i] = z[i-1] + shape[1];
rock_type[i] = rock_type[i-1] + shape[1];
}
set_rock_blocks(rock_type, z, shape[0], shape[1], 2);
for (i=0; i < shape[0]; i++)
g_assert_cmpmem(rock_type[i], shape[1], expected, shape[1]);
free(rock_type[0]);
free(rock_type);
free(z[0]);
free(z);
}
static void fs_version(QVirtIO9P *v9p)
{
const char *version = "9P2000.L";
uint16_t server_len;
char *server_version;
P9Req *req;
req = v9fs_tversion(v9p, P9_MAX_SIZE, version);
v9fs_rversion(req, &server_len, &server_version);
g_assert_cmpmem(server_version, server_len, version, strlen(version));
g_free(server_version);
}
static void pci_config(QVirtIO9P *v9p)
{
size_t tag_len = qvirtio_config_readw(v9p->dev, 0);
char *tag;
int i;
g_assert_cmpint(tag_len, ==, strlen(mount_tag));
tag = g_malloc(tag_len);
for (i = 0; i < tag_len; i++) {
tag[i] = qvirtio_config_readb(v9p->dev, i + 2);
}
g_assert_cmpmem(tag, tag_len, mount_tag, tag_len);
g_free(tag);
}
static void fs_walk_dotdot(QVirtIO9P *v9p)
{
char *const wnames[] = { g_strdup("..") };
v9fs_qid root_qid, *wqid;
P9Req *req;
fs_version(v9p);
req = v9fs_tattach(v9p, 0, getuid());
v9fs_rattach(req, &root_qid);
req = v9fs_twalk(v9p, 0, 1, 1, wnames);
v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */
g_assert_cmpmem(&root_qid, 13, wqid[0], 13);
g_free(wqid);
g_free(wnames[0]);
}
static void
test_parse_bin(StateWrapper *wrapper, gconstpointer user_data)
{
guchar buffer[] = { 0x00, 0x06, 0x00, 0x73, 0x6f, 0x6f, 0x73, 0x68, 0x69 };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = VAL_BIN;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_BYTESTRING));
const gchar *mem = g_variant_get_bytestring(node->value);
g_assert_cmpmem(mem, strlen(mem), buffer + 3, sizeof(buffer) - 3);
g_free(node);
}
static void
test_parse_uint32(StateWrapper *wrapper, gconstpointer user_data)
{
guchar buffer[] = { 0x00, 0x12, 0x34, 0x56, 0x78 };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = VAL_U32;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_UINT32));
g_assert_cmpuint(g_variant_get_uint32(node->value), ==, (guint32) 0x78563412);
guchar buffer2[4];
gint length = sooshi_node_value_to_bytes(node, buffer2);
g_assert_cmpint(length, ==, sizeof(buffer2));
g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1);
g_free(node);
}
static void
test_parse_chooser(StateWrapper *wrapper, gconstpointer user_data)
{
guchar buffer[] = { 0x00, 0x06 };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = CHOOSER;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_BYTE));
g_assert_cmpuint(g_variant_get_byte(node->value), ==, 0x06);
guchar buffer2[1];
gint length = sooshi_node_value_to_bytes(node, buffer2);
g_assert_cmpint(length, ==, sizeof(buffer2));
g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1);
g_free(node);
}
static void
test_parse_str(StateWrapper *wrapper, gconstpointer user_data)
{
guchar buffer[] = { 0x00, 0x06, 0x00, 0x73, 0x6f, 0x6f, 0x73, 0x68, 0x69 };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = VAL_STR;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_STRING));
g_assert_cmpstr(g_variant_get_string(node->value, NULL), ==, "sooshi");
guchar buffer2[8];
gint length = sooshi_node_value_to_bytes(node, buffer2);
g_assert_cmpint(length, ==, sizeof(buffer2));
g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1);
g_free(node);
}
static void
test_parse_int16(StateWrapper *wrapper, gconstpointer user_data)
{
guchar buffer[] = { 0x00, 0xAB, 0xCD };
wrapper->state->buffer = g_byte_array_append(wrapper->state->buffer, buffer, sizeof(buffer));
SooshiNode *node = g_new0(SooshiNode, 1);
node->type = VAL_S16;
sooshi_node_bytes_to_value(node, wrapper->state->buffer, &node->value);
g_assert_nonnull(node->value);
g_assert_true(g_variant_is_of_type(node->value, G_VARIANT_TYPE_INT16));
g_assert_cmpint(g_variant_get_int16(node->value), ==, (gint16) 0xCDAB);
guchar buffer2[2];
gint length = sooshi_node_value_to_bytes(node, buffer2);
g_assert_cmpint(length, ==, sizeof(buffer2));
g_assert_cmpmem(buffer2, length, buffer + 1, sizeof(buffer) - 1);
g_free(node);
}
static void
test_jabber_scram_proofs(void) {
JabberScramData *data = g_new0(JabberScramData, 1);
gboolean ret;
GString *salt;
const char *client_proof;
/* const char *server_signature; */
data->hash = &sha1_mech;
data->password = g_strdup("password");
data->auth_message = g_string_new("[email protected],r=8jLxB5515dhFxBil5A0xSXMH,"
"r=8jLxB5515dhFxBil5A0xSXMHabc,s=c2FsdA==,i=1,"
"c=biws,r=8jLxB5515dhFxBil5A0xSXMHabc");
client_proof = "\x48\x61\x30\xa5\x61\x0b\xae\xb9\xe4\x11\xa8\xfd\xa5\xcd\x34\x1d\x8a\x3c\x28\x17";
salt = g_string_new("salt");
ret = jabber_scram_calc_proofs(data, salt, 1);
g_assert_true(ret);
g_assert_cmpmem(client_proof, 20, data->client_proof->str, 20);
g_string_free(salt, TRUE);
jabber_scram_data_destroy(data);
}
static void pci_basic_config(void)
{
QVirtIO9P *v9p;
size_t tag_len;
char *tag;
int i;
QOSState *qs;
qs = qvirtio_9p_start();
v9p = qvirtio_9p_pci_init(qs);
tag_len = qvirtio_config_readw(v9p->dev, 0);
g_assert_cmpint(tag_len, ==, strlen(mount_tag));
tag = g_malloc(tag_len);
for (i = 0; i < tag_len; i++) {
tag[i] = qvirtio_config_readb(v9p->dev, i + 2);
}
g_assert_cmpmem(tag, tag_len, mount_tag, tag_len);
g_free(tag);
qvirtio_9p_pci_free(v9p);
qvirtio_9p_stop(qs);
}
static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
QVirtQueue *vq)
{
QVirtioBlkReq req;
uint64_t req_addr;
uint64_t capacity;
uint32_t features;
uint32_t free_head;
uint8_t status;
char *data;
capacity = qvirtio_config_readq(dev, 0);
g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
features = qvirtio_get_features(dev);
features = features & ~(QVIRTIO_F_BAD_FEATURE |
(1u << VIRTIO_RING_F_INDIRECT_DESC) |
(1u << VIRTIO_RING_F_EVENT_IDX) |
(1u << VIRTIO_BLK_F_SCSI));
qvirtio_set_features(dev, features);
qvirtio_set_driver_ok(dev);
/* Write and read with 3 descriptor layout */
/* Write request */
req.type = VIRTIO_BLK_T_OUT;
req.ioprio = 1;
req.sector = 0;
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
req_addr = virtio_blk_request(alloc, dev, &req, 512);
g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0);
guest_free(alloc, req_addr);
/* Read request */
req.type = VIRTIO_BLK_T_IN;
req.ioprio = 1;
req.sector = 0;
req.data = g_malloc0(512);
req_addr = virtio_blk_request(alloc, dev, &req, 512);
g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, true, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0);
data = g_malloc0(512);
memread(req_addr + 16, data, 512);
g_assert_cmpstr(data, ==, "TEST");
g_free(data);
guest_free(alloc, req_addr);
if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) {
struct virtio_blk_discard_write_zeroes dwz_hdr;
void *expected;
/*
* WRITE_ZEROES request on the same sector of previous test where
* we wrote "TEST".
*/
req.type = VIRTIO_BLK_T_WRITE_ZEROES;
req.data = (char *) &dwz_hdr;
dwz_hdr.sector = 0;
dwz_hdr.num_sectors = 1;
dwz_hdr.flags = 0;
virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 16 + sizeof(dwz_hdr));
g_assert_cmpint(status, ==, 0);
guest_free(alloc, req_addr);
/* Read request to check if the sector contains all zeroes */
req.type = VIRTIO_BLK_T_IN;
req.ioprio = 1;
req.sector = 0;
req.data = g_malloc0(512);
req_addr = virtio_blk_request(alloc, dev, &req, 512);
g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 512, true, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0);
data = g_malloc(512);
expected = g_malloc0(512);
memread(req_addr + 16, data, 512);
g_assert_cmpmem(data, 512, expected, 512);
g_free(expected);
g_free(data);
guest_free(alloc, req_addr);
}
if (features & (1u << VIRTIO_BLK_F_DISCARD)) {
struct virtio_blk_discard_write_zeroes dwz_hdr;
req.type = VIRTIO_BLK_T_DISCARD;
req.data = (char *) &dwz_hdr;
dwz_hdr.sector = 0;
dwz_hdr.num_sectors = 1;
dwz_hdr.flags = 0;
virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 16 + sizeof(dwz_hdr));
g_assert_cmpint(status, ==, 0);
guest_free(alloc, req_addr);
}
if (features & (1u << VIRTIO_F_ANY_LAYOUT)) {
/* Write and read with 2 descriptor layout */
/* Write request */
req.type = VIRTIO_BLK_T_OUT;
req.ioprio = 1;
req.sector = 1;
req.data = g_malloc0(512);
strcpy(req.data, "TEST");
req_addr = virtio_blk_request(alloc, dev, &req, 512);
g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 528, false, true);
qvirtqueue_add(vq, req_addr + 528, 1, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0);
guest_free(alloc, req_addr);
/* Read request */
req.type = VIRTIO_BLK_T_IN;
req.ioprio = 1;
req.sector = 1;
req.data = g_malloc0(512);
req_addr = virtio_blk_request(alloc, dev, &req, 512);
g_free(req.data);
free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
qvirtqueue_add(vq, req_addr + 16, 513, true, false);
qvirtqueue_kick(dev, vq, free_head);
qvirtio_wait_used_elem(dev, vq, free_head, NULL,
QVIRTIO_BLK_TIMEOUT_US);
status = readb(req_addr + 528);
g_assert_cmpint(status, ==, 0);
data = g_malloc0(512);
memread(req_addr + 16, data, 512);
g_assert_cmpstr(data, ==, "TEST");
g_free(data);
guest_free(alloc, req_addr);
}
