int main(int argc, char **argv)
{
unsigned port = 0;
DskHttpServer *server;
unsigned i;
DskError *error = NULL;
dsk_cmdline_init ("snipez server", "Run a snipez server", NULL, 0);
dsk_cmdline_add_uint ("port", "Port Number",
"PORT", DSK_CMDLINE_MANDATORY, &port);
dsk_cmdline_add_uint ("update-period", "Update Period",
"MILLIS", 0, &update_period_msecs);
dsk_cmdline_add_func ("make-maze", "Make a Maze",
"WIDTHxHEIGHT", DSK_CMDLINE_OPTIONAL,
handle_make_maze, NULL);
dsk_cmdline_add_shortcut ('p', "port");
dsk_cmdline_process_args (&argc, &argv);
server = dsk_http_server_new ();
for (i = 0; i < DSK_N_ELEMENTS (handlers); i++)
{
dsk_http_server_match_save (server);
dsk_http_server_add_match (server, DSK_HTTP_SERVER_MATCH_PATH,
handlers[i].pattern);
dsk_http_server_register_cgi_handler (server,
(DskHttpServerCgiFunc) handlers[i].handler,
NULL, NULL);
dsk_http_server_match_restore (server);
}
if (!dsk_http_server_bind_tcp (server, NULL, port, &error))
dsk_die ("error binding to port %u: %s", port, error->message);
return dsk_main_run ();
}
int main(int argc, char **argv)
{
DskDnsConfigFlags cfg_flags = DSK_DNS_CONFIG_FLAGS_INIT;
dsk_boolean no_searchpath = DSK_FALSE;
int i;
dsk_cmdline_init ("perform DNS lookups",
"Perform DNS lookups with Dsk DNS client.\n",
"HOSTNAMES...",
0);
dsk_cmdline_permit_extra_arguments (DSK_TRUE);
dsk_cmdline_add_boolean ("ipv6", "Lookup names in the IPv6 namespace", NULL, 0, &use_ipv6);
dsk_cmdline_add_boolean ("ipv4", "Lookup names in the IPv4 namespace", NULL, DSK_CMDLINE_REVERSED, &use_ipv6);
dsk_cmdline_add_boolean ("cname", "Return CNAME or POINTER records if they arise", NULL, 0, &no_links);
dsk_cmdline_add_string ("nameserver", "Specify the nameserver to use", "IP", 0, &nameserver);
dsk_cmdline_add_boolean ("verbose", "Print extra messages", NULL, 0, &verbose);
dsk_cmdline_add_boolean ("no-searchpath", "Do not use /etc/resolv.conf's searchpath", NULL, 0, &no_searchpath);
dsk_cmdline_add_boolean ("fatal-errors", "Exit on first error", NULL, 0, &fatal_errors);
dsk_cmdline_process_args (&argc, &argv);
if (no_searchpath)
cfg_flags &= ~DSK_DNS_CONFIG_USE_RESOLV_CONF_SEARCHPATH;
if (nameserver == NULL)
{
/* just use default config */
}
else
{
DskIpAddress addr;
cfg_flags &= ~DSK_DNS_CONFIG_USE_RESOLV_CONF_NS;
if (!dsk_ip_address_parse_numeric (nameserver, &addr))
dsk_error ("error parsing nameserver address (must be numeric)");
dsk_dns_client_add_nameserver (&addr);
}
dsk_dns_client_config (cfg_flags);
if (verbose)
{
dsk_dns_config_dump ();
}
if (argc == 1)
dsk_error ("expected name to resolve");
for (i = 1; i < argc; i++)
{
n_running++;
dsk_dns_lookup (argv[i],
use_ipv6,
handle_dns_result,
argv[i]);
while (n_running >= max_concurrent)
dsk_main_run_once ();
}
dsk_dispatch_destroy_default ();
return exit_status;
}
int main(int argc, char **argv)
{
/* Process command-line arguments. */
dsk_cmdline_init ("a ??? HTTP-Proxy Server",
"Run a simple HTTP Proxy.",
NULL, 0);
dsk_cmdline_add_func ("port", "port to listen on", "PORT",
DSK_CMDLINE_MANDATORY,
handle_port, NULL);
dsk_cmdline_process_args (&argc, &argv);
/* Run forever. */
return dsk_main_run ();
}
int main(int argc, char **argv)
{
unsigned i;
char test_dir_buf[256];
DskError *error = NULL;
dsk_cmdline_init ("test table internals (the 'file' abstraction)",
"Test Table Internals",
NULL, 0);
dsk_cmdline_add_boolean ("verbose", "extra logging", NULL, 0,
&cmdline_verbose);
dsk_cmdline_add_boolean ("slow", "run tests that are fairly slow", NULL, 0,
&cmdline_slow);
dsk_cmdline_add_boolean ("keep-testdir", "do not delete working directory", NULL, 0,
&cmdline_keep_testdir);
dsk_cmdline_process_args (&argc, &argv);
snprintf (test_dir_buf, sizeof (test_dir_buf),
"test-table-file-%u-%u", (unsigned)time(NULL), (unsigned)getpid());
location = dsk_dir_new (NULL, test_dir_buf, DSK_DIR_NEW_MAYBE_CREATE, &error);
if (location == NULL)
dsk_die ("error making directory: %s", error->message);
for (i = 0; i < DSK_N_ELEMENTS (tests); i++)
{
fprintf (stderr, "Test: %s... ", tests[i].name);
tests[i].test ();
fprintf (stderr, " done.\n");
}
if (cmdline_keep_testdir)
{
fprintf (stderr,
"test-table-file: keep-testdir: preserving test directory %s\n",
dsk_dir_get_str (location));
}
else
{
DskError *error = NULL;
if (!dsk_remove_dir_recursive (dsk_dir_get_str (location), &error))
dsk_die ("error removing directory %s: %s",
dsk_dir_get_str (location), error->message);
}
dsk_cleanup ();
return 0;
}
int main(int argc, char **argv)
{
unsigned i;
dsk_cmdline_init ("test HTTP-Header parsing",
"Test the HTTP-Header Parsing Code",
NULL, 0);
dsk_cmdline_add_boolean ("verbose", "extra logging", NULL, 0,
&cmdline_verbose);
dsk_cmdline_process_args (&argc, &argv);
for (i = 0; i < DSK_N_ELEMENTS (tests); i++)
{
fprintf (stderr, "Test: %s... ", tests[i].name);
tests[i].test ();
fprintf (stderr, " done.\n");
}
dsk_cleanup ();
return 0;
}
int main(int argc, char **argv)
{
DskPattern *pattern;
DskError *error = NULL;
dsk_cmdline_init ("grep-like tool",
"Implement 'grep' using DskPattern",
"PATTERN [FILES...]",
DSK_CMDLINE_PERMIT_ARGUMENTS);
dsk_cmdline_process_args (&argc, &argv);
if (argc < 2)
dsk_die ("missing pattern");
DskPatternEntry entry = { argv[1], "nonnull" };
pattern = dsk_pattern_compile (1, &entry, &error);
if (pattern == NULL)
dsk_die ("error compiling pattern: %s", error->message);
unsigned buffer_size = isatty (STDOUT_FILENO) ? 0 : 8192;
if (argc == 2)
handle_fd (pattern, NULL, buffer_size, 0);
else
{
int i;
for (i = 2; i < argc; i++)
{
int fd = open (argv[i], O_RDONLY);
if (fd < 0)
dsk_die ("error opening %s: %s", argv[i], strerror (errno));
handle_fd (pattern, argc == 3 ? NULL : argv[i], buffer_size, fd);
close (fd);
}
}
return 0;
}
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;
}
