void random_slice(DskBuffer* buf)
{
DskBuffer tmpbuf;
char *copy, *copy_at;
unsigned orig_size = buf->size;
dsk_buffer_init (&tmpbuf);
copy = dsk_malloc (buf->size);
copy_at = copy;
while (1)
{
int r;
r = (rand () % 16384) + 1;
r = dsk_buffer_read (buf, r, copy_at);
dsk_buffer_append (&tmpbuf, r, copy_at);
if (r == 0)
break;
}
dsk_assert (copy_at == copy + orig_size);
dsk_assert (buf->size == 0);
dsk_assert (tmpbuf.size == orig_size);
copy_at = dsk_malloc (orig_size);
dsk_assert (dsk_buffer_read (&tmpbuf, orig_size, copy_at) == orig_size);
dsk_assert (dsk_buffer_read (&tmpbuf, orig_size, copy_at) == 0);
dsk_assert (memcmp (copy, copy_at, orig_size) == 0);
dsk_free (copy);
dsk_free (copy_at);
}
void count(DskBuffer* buf, int start, int end)
{
char b[1024];
while (start <= end)
{
sprintf (b, "%d\n", start++);
dsk_buffer_append (buf, strlen (b), b);
}
}
static dsk_boolean
dsk_xml_escaper_process (DskOctetFilter *filter,
DskBuffer *out,
unsigned in_length,
const uint8_t *in_data,
DskError **error)
{
DSK_UNUSED (filter);
DSK_UNUSED (error);
while (in_length > 0)
{
unsigned n = 0;
while (n < in_length && in_data[n] != '<' && in_data[n] != '>'
&& in_data[n] != '&')
n++;
if (n)
dsk_buffer_append (out, n, in_data);
in_data += n;
in_length -= n;
while (in_length > 0)
if (*in_data == '<')
{
in_data++;
in_length--;
dsk_buffer_append (out, 4, "<");
}
else if (*in_data == '>')
{
in_data++;
in_length--;
dsk_buffer_append (out, 4, ">");
}
else if (*in_data == '&')
{
in_data++;
in_length--;
dsk_buffer_append (out, 5, "&");
}
else
break;
}
return DSK_TRUE;
}
static DskHttpRequest *
try_parse_request_from_string (const char *str,
DskError **error)
{
unsigned len = strlen (str);
DskBuffer buffer = DSK_BUFFER_INIT;
DskHttpRequest *rv;
dsk_buffer_append (&buffer, len, str);
rv = dsk_http_request_parse_buffer (&buffer, len, error);
dsk_buffer_clear (&buffer);
return rv;
}
static void
handle_bad_char (DskUtf8Fixer *fixer,
DskBuffer *out,
uint8_t c)
{
char buf[6];
switch (fixer->mode)
{
case DSK_UTF8_FIXER_DROP:
break;
case DSK_UTF8_FIXER_LATIN1:
dsk_buffer_append (out, dsk_utf8_encode_unichar (buf, c), buf);
break;
}
}
static DskIOResult
dsk_memory_sink_write (DskOctetSink *sink,
unsigned max_len,
const void *data_out,
unsigned *n_written_out,
DskError **error)
{
DskMemorySink *msink = DSK_MEMORY_SINK (sink);
DSK_UNUSED (error);
if (msink->buffer.size >= msink->max_buffer_size)
return DSK_IO_RESULT_AGAIN;
if (msink->buffer.size + max_len <= msink->max_buffer_size)
*n_written_out = max_len;
else
*n_written_out = msink->max_buffer_size - msink->buffer.size;
dsk_buffer_append (&msink->buffer, *n_written_out, data_out);
dsk_hook_set_idle_notify (&msink->buffer_nonempty, DSK_TRUE);
return DSK_IO_RESULT_SUCCESS;
}
int main(int argc, char** argv)
{
DskBuffer gskbuffer;
char buf[1024];
char *str;
dsk_cmdline_init ("test dsk-buffer code", "test DskBuffer", NULL, 0);
dsk_cmdline_process_args (&argc, &argv);
dsk_buffer_init (&gskbuffer);
dsk_assert (gskbuffer.size == 0);
dsk_buffer_append (&gskbuffer, 5, "hello");
dsk_assert (gskbuffer.size == 5);
dsk_assert (dsk_buffer_read (&gskbuffer, sizeof (buf), buf) == 5);
dsk_assert (memcmp (buf, "hello", 5) == 0);
dsk_assert (gskbuffer.size == 0);
dsk_buffer_clear (&gskbuffer);
dsk_buffer_init (&gskbuffer);
count (&gskbuffer, 1, 100000);
decount (&gskbuffer, 1, 100000);
dsk_assert (gskbuffer.size == 0);
dsk_buffer_clear (&gskbuffer);
dsk_buffer_init (&gskbuffer);
dsk_buffer_append_string (&gskbuffer, "hello\na\nb");
str = dsk_buffer_read_line (&gskbuffer);
dsk_assert (str);
dsk_assert (strcmp (str, "hello") == 0);
dsk_free (str);
str = dsk_buffer_read_line (&gskbuffer);
dsk_assert (str);
dsk_assert (strcmp (str, "a") == 0);
dsk_free (str);
dsk_assert (gskbuffer.size == 1);
dsk_assert (dsk_buffer_read_line (&gskbuffer) == NULL);
dsk_buffer_append_byte (&gskbuffer, '\n');
str = dsk_buffer_read_line (&gskbuffer);
dsk_assert (str);
dsk_assert (strcmp (str, "b") == 0);
dsk_free (str);
dsk_assert (gskbuffer.size == 0);
dsk_buffer_clear (&gskbuffer);
dsk_buffer_init (&gskbuffer);
dsk_buffer_append (&gskbuffer, 5, "hello");
dsk_buffer_append_foreign (&gskbuffer, 4, "test", NULL, NULL);
dsk_buffer_append (&gskbuffer, 5, "hello");
dsk_assert (gskbuffer.size == 14);
dsk_assert (dsk_buffer_read (&gskbuffer, sizeof (buf), buf) == 14);
dsk_assert (memcmp (buf, "hellotesthello", 14) == 0);
dsk_assert (gskbuffer.size == 0);
/* Test that the foreign data really is not being stored in the DskBuffer */
{
char test_str[5];
strcpy (test_str, "test");
dsk_buffer_init (&gskbuffer);
dsk_buffer_append (&gskbuffer, 5, "hello");
dsk_buffer_append_foreign (&gskbuffer, 4, test_str, NULL, NULL);
dsk_buffer_append (&gskbuffer, 5, "hello");
dsk_assert (gskbuffer.size == 14);
dsk_assert (dsk_buffer_peek (&gskbuffer, sizeof (buf), buf) == 14);
dsk_assert (memcmp (buf, "hellotesthello", 14) == 0);
test_str[1] = '3';
dsk_assert (gskbuffer.size == 14);
dsk_assert (dsk_buffer_read (&gskbuffer, sizeof (buf), buf) == 14);
dsk_assert (memcmp (buf, "hellot3sthello", 14) == 0);
dsk_buffer_clear (&gskbuffer);
}
/* Test str_index_of */
{
DskBuffer buffer = DSK_BUFFER_INIT;
dsk_buffer_append_foreign (&buffer, 3, "abc", NULL, NULL);
dsk_buffer_append_foreign (&buffer, 3, "def", NULL, NULL);
dsk_buffer_append_foreign (&buffer, 3, "gad", NULL, NULL);
#if 0
dsk_assert (dsk_buffer_str_index_of (&buffer, "cdefg") == 2);
dsk_assert (dsk_buffer_str_index_of (&buffer, "ad") == 7);
dsk_assert (dsk_buffer_str_index_of (&buffer, "ab") == 0);
dsk_assert (dsk_buffer_str_index_of (&buffer, "a") == 0);
dsk_assert (dsk_buffer_str_index_of (&buffer, "g") == 6);
#endif
dsk_buffer_clear (&buffer);
}
static const char *before_strs[] = {
"",
"foo",
NULL, NULL
};
before_strs[2] = generate_str (100, 1000);
before_strs[3] = generate_str (10000, 100000);
static const char *placeholder_strs[] = {
"",
"bar",
NULL, NULL, NULL
};
placeholder_strs[2] = generate_str (100, 1000);
placeholder_strs[3] = generate_str (10000, 100000);
placeholder_strs[4] = generate_str (100000, 1000000);
static const char *after_strs[] = {
"",
"foo",
NULL, NULL
};
after_strs[2] = generate_str (100, 1000);
after_strs[3] = generate_str (10000, 100000);
unsigned bi, pi, ai;
for (bi = 0; bi < DSK_N_ELEMENTS (before_strs); bi++)
for (pi = 0; pi < DSK_N_ELEMENTS (placeholder_strs); pi++)
for (ai = 0; ai < DSK_N_ELEMENTS (after_strs); ai++)
{
DskBuffer buffer = DSK_BUFFER_INIT;
const char *pi_str = placeholder_strs[pi];
DskBufferPlaceholder placeholder;
dsk_buffer_append_string (&buffer, before_strs[bi]);
dsk_buffer_append_placeholder (&buffer, strlen (pi_str), &placeholder);
dsk_buffer_append_string (&buffer, after_strs[ai]);
dsk_buffer_placeholder_set (&placeholder, pi_str);
dsk_assert (try_initial_remove (&buffer, before_strs[bi]));
dsk_assert (try_initial_remove (&buffer, pi_str));
dsk_assert (try_initial_remove (&buffer, after_strs[ai]));
dsk_assert (buffer.size == 0);
}
return 0;
}
static dsk_boolean
dsk_utf8_fixer_process (DskOctetFilter *filter,
DskBuffer *out,
unsigned in_length,
const uint8_t *in_data,
DskError **error)
{
DskUtf8Fixer *fixer = (DskUtf8Fixer *) filter;
DSK_UNUSED (error);
retry_spare:
if (fixer->spare_len)
{
unsigned used = 6 - fixer->spare_len;
unsigned u;
if (used < in_length)
used = in_length;
memcpy (fixer->spare + fixer->spare_len, in_data, used);
switch (dsk_utf8_validate (fixer->spare_len + used, (char*) fixer->spare, &u))
{
case DSK_UTF8_VALIDATION_SUCCESS:
dsk_buffer_append (out, fixer->spare_len, fixer->spare);
in_length -= used;
in_data += used;
fixer->spare_len = 0;
break;
case DSK_UTF8_VALIDATION_PARTIAL:
dsk_assert (u > fixer->spare_len);
dsk_buffer_append (out, u, fixer->spare);
in_length -= u - fixer->spare_len;
in_data += u - fixer->spare_len;
fixer->spare_len = 0;
break;
case DSK_UTF8_VALIDATION_INVALID:
dsk_buffer_append (out, u, fixer->spare);
if (u < fixer->spare_len)
{
handle_bad_char (fixer, out, fixer->spare[u]);
u++;
memmove (fixer->spare, fixer->spare + u, fixer->spare_len - u);
fixer->spare_len -= u;
goto retry_spare;
}
else
{
in_length -= u - fixer->spare_len;
in_data += u - fixer->spare_len;
fixer->spare_len = 0;
}
break;
}
}
while (in_length)
{
unsigned used;
switch (dsk_utf8_validate (in_length, (char*) in_data, &used))
{
case DSK_UTF8_VALIDATION_SUCCESS:
dsk_buffer_append (out, used, in_data);
return DSK_TRUE;
case DSK_UTF8_VALIDATION_PARTIAL:
dsk_assert (in_length - used <= 6);
dsk_buffer_append (out, used, in_data);
fixer->spare_len = in_length - used;
memcpy (fixer->spare, in_data, fixer->spare_len);
return DSK_TRUE;
case DSK_UTF8_VALIDATION_INVALID:
if (used > 0)
{
dsk_buffer_append (out, used, in_data);
in_data += used;
in_length -= used;
}
dsk_assert (in_length > 0);
dsk_assert (*in_data >= 128);
handle_bad_char (fixer, out, *in_data);
in_length--;
in_data++;
break;
}
}
return DSK_TRUE;
}
