int rinoo_dns_record_get(t_buffer_iterator *iterator, t_dns_record *record)
{
buffer_set(&record->name.buffer, record->name.value, sizeof(record->name.value));
if (rinoo_dns_name_get(iterator, &record->name.buffer) != 0) {
return -1;
}
if (buffer_iterator_gethushort(iterator, &record->type) != 0) {
return -1;
}
switch (record->type) {
case DNS_TYPE_A:
break;
case DNS_TYPE_NS:
buffer_set(&record->rdata.ns.nsname.buffer, record->rdata.ns.nsname.value, sizeof(record->rdata.ns.nsname.value));
break;
case DNS_TYPE_CNAME:
buffer_set(&record->rdata.cname.cname.buffer, record->rdata.cname.cname.value, sizeof(record->rdata.cname.cname.value));
break;
case DNS_TYPE_SOA:
buffer_set(&record->rdata.soa.mname.buffer, record->rdata.soa.mname.value, sizeof(record->rdata.soa.mname.value));
buffer_set(&record->rdata.soa.rname.buffer, record->rdata.soa.rname.value, sizeof(record->rdata.soa.rname.value));
break;
case DNS_TYPE_PTR:
buffer_set(&record->rdata.ptr.ptrname.buffer, record->rdata.ptr.ptrname.value, sizeof(record->rdata.ptr.ptrname));
break;
case DNS_TYPE_HINFO:
buffer_set(&record->rdata.hinfo.cpu.buffer, record->rdata.hinfo.cpu.value, sizeof(record->rdata.hinfo.cpu.value));
buffer_set(&record->rdata.hinfo.os.buffer, record->rdata.hinfo.os.value, sizeof(record->rdata.hinfo.os.value));
break;
case DNS_TYPE_MX:
buffer_set(&record->rdata.mx.exchange.buffer, record->rdata.mx.exchange.value, sizeof(record->rdata.mx.exchange.value));
break;
case DNS_TYPE_TXT:
buffer_set(&record->rdata.txt.txtdata.buffer, record->rdata.txt.txtdata.value, sizeof(record->rdata.txt.txtdata.value));
break;
}
if (buffer_iterator_gethushort(iterator, &record->aclass) != 0) {
return -1;
}
if (buffer_iterator_gethint(iterator, &record->ttl) != 0) {
return -1;
}
if (buffer_iterator_gethushort(iterator, &record->rdlength) != 0) {
return -1;
}
if (rinoo_dns_rdata_get(iterator, record->rdlength, record->type, &record->rdata) != 0) {
return -1;
}
return 0;
}
void TestGame::scan_line(int y, Vertex * va, Vertex * vb, Vertex * vc,
Vertex * vd, Texture * texture) {
float gradient1 = va->coordinates.y != vb->coordinates.y ?
(y - va->coordinates.y) / (vb->coordinates.y - va->coordinates.y) : 1,
gradient2 = vc->coordinates.y != vd->coordinates.y ?
(y - vc->coordinates.y) / (vd->coordinates.y - vc->coordinates.y) : 1;
int sx = (int)interpolate(va->coordinates.x, vb->coordinates.x, gradient1),
ex = (int)interpolate(vc->coordinates.x, vd->coordinates.x, gradient2);
float z1 = interpolate(va->coordinates.z, vb->coordinates.z, gradient1),
z2 = interpolate(vc->coordinates.z, vd->coordinates.z, gradient2),
su = interpolate(va->texture_coordinates.x, vb->texture_coordinates.x,
gradient1),
eu = interpolate(vc->texture_coordinates.x, vd->texture_coordinates.x,
gradient2),
sv = interpolate(va->texture_coordinates.y, vb->texture_coordinates.y,
gradient1),
ev = interpolate(vc->texture_coordinates.y, vd->texture_coordinates.y,
gradient2);
for (int x = sx; x < ex; x++) {
float gradient = (float)(x - sx) / (ex - sx);
float z = interpolate(z1, z2, gradient);
if (!buffer_check(x, y, z)) continue;
buffer_set(x, y, z, texture->map(
interpolate(su, eu, gradient),
interpolate(sv, ev, gradient)));
}
}
// Allocates and returns a new Buffer with a copy of a range of another Buffer.
Buffer buffer_slice(const Buffer *buffer, size_t size, size_t offset)
{
//FIXME: Range check problem. Need to cover if size and/or offset are too large (three states).
if ((size + offset) > malloc_size(buffer->data)) {
size = malloc_size(buffer->data) - offset;
}
Buffer new_buffer = buffer_alloc(size);
buffer_set(&new_buffer, buffer->data+offset, size);
return new_buffer;
}
/* variable_serialize */
int variable_serialize(Variable * variable, Buffer * buffer, int type)
{
size_t size = 0;
size_t offset;
void * p;
uint8_t u8;
int16_t i16;
uint16_t u16;
int32_t i32;
uint32_t u32;
char buf[16];
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s(%u)\n", __func__, variable->type);
#endif
switch(variable->type)
{
case VT_NULL:
p = NULL;
break;
case VT_BOOL:
case VT_INT8:
case VT_UINT8:
size = sizeof(variable->u.int8);
p = &variable->u.int8;
break;
case VT_INT16:
size = sizeof(i16);
i16 = htons(variable->u.int16);
p = &i16;
break;
case VT_UINT16:
size = sizeof(u16);
u16 = htons(variable->u.uint16);
p = &u16;
break;
case VT_INT32:
size = sizeof(i32);
i32 = htonl(variable->u.int32);
p = &i32;
break;
case VT_UINT32:
size = sizeof(u32);
u32 = htonl(variable->u.uint32);
p = &u32;
break;
case VT_INT64:
case VT_UINT64:
/* FIXME convert to network endian */
size = sizeof(variable->u.int64);
p = &variable->u.int64;
break;
case VT_FLOAT:
size = snprintf(buf, sizeof(buf), "%.e", variable->u.f);
p = buf;
break;
case VT_DOUBLE:
size = snprintf(buf, sizeof(buf), "%.e", variable->u.d);
p = buf;
break;
case VT_BUFFER:
size = buffer_get_size(variable->u.buffer);
u32 = buffer_get_size(variable->u.buffer);
u32 = htonl(u32);
p = buffer_get_data(variable->u.buffer);
break;
case VT_STRING:
size = string_get_length(variable->u.string) + 1;
p = variable->u.string;
break;
}
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() %lu\n", __func__, size);
#endif
if(size == 0 && variable->type != VT_NULL)
return -error_set_code(1, "Unable to serialize type %u", type);
if(type)
{
/* prefix with the type */
u8 = variable->type;
if(buffer_set(buffer, sizeof(u8), (char *)&u8) != 0)
return -1;
offset = sizeof(u8);
if(variable->type == VT_BUFFER)
{
if(buffer_set_data(buffer, offset, (char *)&u32,
sizeof(u32)) != 0)
return -1;
offset += sizeof(u32);
}
return buffer_set_data(buffer, offset, p, size);
}
if(variable->type == VT_BUFFER)
{
if(buffer_set(buffer, sizeof(u32), (char *)&u32) != 0)
return -1;
return buffer_set_data(buffer, sizeof(u32), p, size);
}
return buffer_set(buffer, size, p);
}
int
main(void)
{
struct buffer one = { 0, 0, 0, NULL };
struct buffer two = { 0, 0, 0, NULL };
struct buffer *three;
int fd;
char *data;
ssize_t count;
size_t offset;
plan(89);
/* buffer_set, buffer_append, buffer_swap */
buffer_set(&one, test_string1, sizeof(test_string1));
is_int(1024, one.size, "minimum size is 1024");
is_int(0, one.used, "used starts at 0");
is_int(sizeof(test_string1), one.left, "left is correct");
is_string(test_string1, one.data, "data is corect");
buffer_append(&one, test_string2, sizeof(test_string2));
is_int(1024, one.size, "appended data doesn't change size");
is_int(0, one.used, "or used");
is_int(sizeof(test_string3), one.left, "but left is the right size");
ok(memcmp(one.data, test_string3, sizeof(test_string3)) == 0,
"and the resulting data is correct");
one.left -= sizeof(test_string1);
one.used += sizeof(test_string1);
buffer_append(&one, test_string1, sizeof(test_string1));
is_int(1024, one.size, "size still isn't larger after adding data");
is_int(sizeof(test_string1), one.used, "and used is preserved on append");
is_int(sizeof(test_string3), one.left, "and left is updated properly");
ok(memcmp(one.data + one.used, test_string2, sizeof(test_string2)) == 0,
"and the middle data is unchanged");
ok(memcmp(one.data + one.used + sizeof(test_string2), test_string1,
sizeof(test_string1)) == 0, "and the final data is correct");
buffer_set(&one, test_string1, sizeof(test_string1));
buffer_set(&two, test_string2, sizeof(test_string2));
buffer_swap(&one, &two);
is_int(1024, one.size, "swap #1 size is correct");
is_int(0, one.used, "swap #1 used is correct");
is_int(sizeof(test_string2), one.left, "swap #1 left is correct");
is_string(test_string2, one.data, "swap #1 data is correct");
is_int(1024, two.size, "swap #2 size is correct");
is_int(0, two.used, "swap #2 used is correct");
is_int(sizeof(test_string1), two.left, "swap #2 left is correct");
is_string(test_string1, two.data, "swap #2 data is correct");
free(one.data);
free(two.data);
one.data = NULL;
two.data = NULL;
one.size = 0;
two.size = 0;
/* buffer_resize */
three = buffer_new();
ok(three != NULL, "buffer_new works");
if (three == NULL)
bail("buffer_new returned NULL");
is_int(0, three->size, "initial size is 0");
buffer_set(three, test_string1, sizeof(test_string1));
is_int(1024, three->size, "size becomes 1024 when adding data");
buffer_resize(three, 512);
is_int(1024, three->size, "resizing to something smaller doesn't change");
buffer_resize(three, 1025);
is_int(2048, three->size, "resizing to something larger goes to 2048");
buffer_free(three);
/* buffer_read, buffer_find_string, buffer_compact */
fd = open("buffer-test", O_RDWR | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
sysbail("cannot create buffer-test");
data = bmalloc(2048);
memset(data, 'a', 1023);
data[1023] = '\r';
data[1024] = '\n';
memset(data + 1025, 'b', 1023);
if (xwrite(fd, data, 2048) < 2048)
sysbail("cannot write to buffer-test");
if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
sysbail("cannot rewind buffer-test");
three = buffer_new();
ok(three != NULL, "buffer_new works");
if (three == NULL)
bail("buffer_new returned NULL");
is_int(0, three->size, "and initial size is 0");
buffer_resize(three, 1024);
is_int(1024, three->size, "resize to 1024 works");
count = buffer_read(three, fd);
is_int(1024, count, "reading into a buffer of size 1024 reads 1024");
offset = 0;
ok(!buffer_find_string(three, "\r\n", 0, &offset),
"buffer_find_string with truncated string fails");
is_int(0, offset, "and offset is unchanged");
ok(memcmp(three->data, data, three->size) == 0, "buffer data is correct");
buffer_resize(three, 2048);
is_int(2048, three->size, "resizing the buffer to 2048 works");
count = buffer_read(three, fd);
is_int(1024, count, "and now we can read the rest of the data");
ok(memcmp(three->data, data, 2048) == 0, "and it's all there");
ok(!buffer_find_string(three, "\r\n", 1024, &offset),
"buffer_find_string with a string starting before offset fails");
is_int(0, offset, "and offset is unchanged");
ok(buffer_find_string(three, "\r\n", 0, &offset),
"finding the string on the whole buffer works");
is_int(1023, offset, "and returns the correct location");
three->used += 400;
three->left -= 400;
buffer_compact(three);
is_int(2048, three->size, "compacting buffer doesn't change the size");
is_int(0, three->used, "but used is now zero");
is_int(1648, three->left, "and left is decreased appropriately");
ok(memcmp(three->data, data + 400, 1648) == 0, "and the data is correct");
count = buffer_read(three, fd);
is_int(0, count, "reading at EOF returns 0");
close(fd);
unlink("buffer-test");
free(data);
buffer_free(three);
/* buffer_sprintf and buffer_append_sprintf */
three = buffer_new();
buffer_append_sprintf(three, "testing %d testing", 6);
is_int(0, three->used, "buffer_append_sprintf doesn't change used");
is_int(17, three->left, "but sets left correctly");
buffer_append(three, "", 1);
is_int(18, three->left, "appending a nul works");
is_string("testing 6 testing", three->data, "and the data is correct");
three->left--;
three->used += 5;
three->left -= 5;
buffer_append_sprintf(three, " %d", 7);
is_int(14, three->left, "appending a digit works");
buffer_append(three, "", 1);
is_string("testing 6 testing 7", three->data, "and the data is correct");
buffer_sprintf(three, "%d testing", 8);
is_int(9, three->left, "replacing the buffer works");
is_string("8 testing", three->data, "and the results are correct");
data = bmalloc(1050);
memset(data, 'a', 1049);
data[1049] = '\0';
is_int(1024, three->size, "size before large sprintf is 1024");
buffer_sprintf(three, "%s", data);
is_int(2048, three->size, "size after large sprintf is 2048");
is_int(1049, three->left, "and left is correct");
buffer_append(three, "", 1);
is_string(data, three->data, "and data is correct");
free(data);
buffer_free(three);
/* buffer_read_all */
fd = open("buffer-test", O_RDWR | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
sysbail("cannot create buffer-test");
data = bmalloc(2049);
memset(data, 'a', 2049);
if (xwrite(fd, data, 2049) < 2049)
sysbail("cannot write to buffer-test");
if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
sysbail("cannot rewind buffer-test");
three = buffer_new();
ok(buffer_read_all(three, fd), "buffer_read_all succeeds");
is_int(0, three->used, "and unused is zero");
is_int(2049, three->left, "and left is correct");
is_int(4096, three->size, "and size is correct");
ok(memcmp(data, three->data, 2049) == 0, "and data is correct");
if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
sysbail("cannot rewind buffer-test");
ok(buffer_read_all(three, fd), "reading again succeeds");
is_int(0, three->used, "and used is correct");
is_int(4098, three->left, "and left is now larger");
is_int(8192, three->size, "and size doubled");
ok(memcmp(data, three->data + 2049, 2049) == 0, "and data is correct");
/* buffer_read_file */
if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
sysbail("cannot rewind buffer-test");
buffer_free(three);
three = buffer_new();
ok(buffer_read_file(three, fd), "buffer_read_file succeeds");
is_int(0, three->used, "and leaves unused at 0");
is_int(2049, three->left, "and left is correct");
is_int(3072, three->size, "and size is a multiple of 1024");
ok(memcmp(data, three->data, 2049) == 0, "and the data is correct");
/* buffer_read_all and buffer_read_file errors */
close(fd);
ok(!buffer_read_all(three, fd), "buffer_read_all on closed fd fails");
is_int(3072, three->size, "and size is unchanged");
ok(!buffer_read_file(three, fd), "buffer_read_file on closed fd fails");
is_int(3072, three->size, "and size is unchanged");
is_int(2049, three->left, "and left is unchanged");
unlink("buffer-test");
free(data);
buffer_free(three);
/* buffer_vsprintf and buffer_append_vsprintf */
three = buffer_new();
test_append_vsprintf(three, "testing %d testing", 6);
is_int(0, three->used, "buffer_append_vsprintf leaves used as 0");
is_int(17, three->left, "and left is correct");
buffer_append(three, "", 1);
is_int(18, three->left, "and left is correct after appending a nul");
is_string("testing 6 testing", three->data, "and data is correct");
three->left--;
three->used += 5;
three->left -= 5;
test_append_vsprintf(three, " %d", 7);
is_int(14, three->left, "and appending results in the correct left");
buffer_append(three, "", 1);
is_string("testing 6 testing 7", three->data, "and the right data");
test_vsprintf(three, "%d testing", 8);
is_int(9, three->left, "replacing the buffer results in the correct size");
is_string("8 testing", three->data, "and the correct data");
data = bmalloc(1050);
memset(data, 'a', 1049);
data[1049] = '\0';
is_int(1024, three->size, "size is 1024 before large vsprintf");
test_vsprintf(three, "%s", data);
is_int(2048, three->size, "and 2048 afterwards");
is_int(1049, three->left, "and left is correct");
buffer_append(three, "", 1);
is_string(data, three->data, "and data is correct");
free(data);
buffer_free(three);
/* Test buffer_free with NULL and ensure it doesn't explode. */
buffer_free(NULL);
return 0;
}
int buffer_init_contents(buffer_t *b, const char *data, size_t size)
{
buffer_allocate(b, size);
return buffer_set(b, data, size);
}
/*
* Replace the current buffer contents with data printed from the supplied
* va_list. The new data shows up as unused data at the end of the buffer.
* The trailing nul is not added to the buffer.
*/
void
buffer_vsprintf(struct buffer *buffer, const char *format, va_list args)
{
buffer_set(buffer, NULL, 0);
buffer_append_vsprintf(buffer, format, args);
}
